splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToSetMatcher < SetMatcher
+    MATCHER_TYPE = 'EQUAL_TO_SET'
+
+    attr_reader :attribute
+
+    def match?(args)
+      set = local_set(args[:attributes], @attribute)
+      matches = set == @remote_set
+      @logger.log_if_debug("[EqualsToSetMatcher] #{set} equals to #{@remote_set} -> #{matches}")
+      matches
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class GreaterThanOrEqualToMatcher < Matcher
+    MATCHER_TYPE = 'GREATER_THAN_OR_EQUAL_TO'
+
+    attr_reader :attribute
+
+    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)
+      @logger.log_if_debug('[GreaterThanOrEqualToMatcher] evaluating value and attributes.')
+
+      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
+      @logger.log_if_debug("[GreaterThanOrEqualToMatcher] #{value} greater than or equal to #{@value} -> #{matches}")
+      matches
+    end
+
+    private
+
+    def formatted_value(value, sdk_data = false)
+      case @data_type
+      when 'NUMBER'
+        value
+      when 'DATETIME'
+        value /= 1000 if sdk_data # sdk returns already miliseconds, turning to seconds to do a correct zero_hour
+        SplitIoClient::Utilities.to_milis_zero_out_from_seconds(value)
+      else
+        @logger.error('Invalid data type')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class LessThanOrEqualToMatcher < Matcher
+    MATCHER_TYPE = 'LESS_THAN_OR_EQUAL_TO'
+
+    attr_reader :attribute
+
+    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)
+      @logger.log_if_debug('[LessThanOrEqualToMatcher] evaluating value and attributes.')
+
+      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
+      @logger.log_if_debug("[LessThanOrEqualToMatcher] #{value} less than or equal to #{@value} -> #{matches}")
+      matches
+    end
+
+    private
+
+    def formatted_value(value, sdk_data = false)
+      case @data_type
+      when 'NUMBER'
+        value
+      when 'DATETIME'
+        value /= 1000 if sdk_data # sdk returns already miliseconds, turning to seconds to do a correct zero_hour
+        SplitIoClient::Utilities.to_milis_zero_out_from_seconds(value)
+      else
+        @logger.error('Invalid data type')
+      end
+    end
+  end
+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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+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
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @return [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(self.class)
+        false
+      elsif equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class MatchesStringMatcher
+    MATCHER_TYPE = 'MATCHES_STRING'
+
+    attr_reader :attribute
+
+    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)
+      value = args[:value] || args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+
+      matches = !(value =~ @regexp_string).nil?
+      @logger.log_if_debug("[MatchesStringMatcher] #{value} matches #{@regexp_string} -> #{matches}")
+      matches
+    end
+
+    def string_type?
+      true
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  #
+  # class to implement the negation of a matcher
+  #
+  class NegationMatcher < Matcher
+    MATCHER_TYPE = 'NEGATION_MATCHER'
+
+    def initialize(logger, matcher = nil)
+      super(logger)
+      @matcher = matcher
+    end
+
+    #
+    # evaluates if the key matches the negation of the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the negation matcher
+    def match?(args)
+      matches = !@matcher.match?(args)
+      @logger.log_if_debug("[NegationMatcherMatcher] Matcher #{@matcher} Arguments #{args} -> #{matches}")
+      matches
+    end
+
+    def respond_to?(method)
+      @matcher.respond_to? method
+    end
+
+    def attribute
+      @matcher.attribute
+    end
+
+    def string_type?
+      @matcher.string_type?
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @return [string] string value of this matcher
+    def to_s
+      "not #{@matcher}"
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class PartOfSetMatcher < SetMatcher
+    MATCHER_TYPE = 'PART_OF_SET'
+
+    attr_reader :attribute
+
+    def match?(args)
+      @local_set = local_set(args[:attributes], @attribute)
+
+      if @local_set.empty?
+        @logger.log_if_debug('[PartOfSetMatcher] Local Set is empty.')
+        return false
+      end
+
+      matches = @local_set.subset? @remote_set
+      @logger.log_if_debug("[PartOfSetMatcher] Local Set #{@local_set} is a subset of #{@remote_set} -> #{matches}")
+      matches
+    end
+  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
+
+      @config.logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matched}") if @config.debug_enabled
+      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