splitclient-rb 0.1.3

data/lib/splitclient-engine/evaluator/splitter.rb

@@ -0,0 +1,110 @@
+module SplitIoClient
+  # Misc class in charge of providing hash functions and
+  # determination of treatment based on concept of buckets
+  # based on provided key
+  #
+  class Splitter < NoMethodError
+
+    #
+    # Checks if the partiotion size is 100%
+    #
+    # @param partitions [object] array of partitions
+    #
+    # @return [boolean] true if partition is 100% false otherwise
+    def self.hundred_percent_one_treatment?(partitions)
+      if partitions.size != 1
+        return false
+      end
+      return (partitions.first).size == 100
+    end
+
+
+    #
+    # gets the appropriate treatment based on id, seed and partition value
+    #
+    # @param id [string] user key
+    # @param seed [number] seed for the user key
+    # @param partitions [object] array of partitions
+    #
+    # @return traetment [object] treatment value
+    def self.get_treatment(id, seed, partitions)
+      if partitions.empty?
+        return Treatments::CONTROL
+      end
+
+      if hundred_percent_one_treatment?(partitions)
+        return (partitions.first).treatment
+      end
+
+      return get_treatment_for_key(bucket(hash(id, seed)), partitions)
+    end
+
+    #
+    # returns a hash value for the give key, sedd pair
+    #
+    # @param key [string] user key
+    # @param seed [number] seed for the user key
+    #
+    # @return hash [string] hash value
+    def self.hash(key, seed)
+      h = 0
+      for i in 0..key.length-1
+        h = to_int32(31 * h + key[i].ord)
+      end
+      h^seed
+    end
+
+    #
+    # misc method to convert ruby number to int 32 since overflow is handled different to java
+    #
+    # @param number [number] ruby number value
+    #
+    # @return [int] returns the int 32 value of the provided number
+    def self.to_int32(number)
+      begin
+        sign = number < 0 ? -1 : 1
+        abs = number.abs
+        return 0 if abs == 0 || abs == Float::INFINITY
+      rescue
+        return 0
+      end
+
+      pos_int = sign * abs.floor
+      int_32bit = pos_int % 2**32
+
+      return int_32bit - 2**32 if int_32bit >= 2**31
+      int_32bit
+    end
+
+    #
+    # returns the treatment for a bucket given the partitions
+    #
+    # @param bucket [number] bucket value
+    # @param parittions [object] array of partitions
+    #
+    # @return treatment [treatment] treatment value for this bucket and partitions
+    def self.get_treatment_for_key(bucket, partitions)
+      buckets_covered_thus_far = 0
+      partitions.each do |p|
+        unless p.is_empty?
+          buckets_covered_thus_far += p.size
+          return p.treatment if buckets_covered_thus_far >= bucket
+        end
+      end
+
+      return Treatments::CONTROL
+    end
+
+    #
+    # returns bucket value for the given hash value
+    #
+    # @param hash_value [string] hash value
+    #
+    # @return bucket [number] bucket number
+    def self.bucket(hash_value)
+      (hash_value.abs % 100) + 1
+    end
+
+  end
+
+end

data/lib/splitclient-engine/impressions/impressions.rb

@@ -0,0 +1,79 @@
+module SplitIoClient
+
+  #
+  # class to manage cached impressions
+  #
+  class Impressions < NoMethodError
+
+    # the queue of cached impression values
+    #
+    # @return [object] array of impressions
+    attr_accessor :queue
+
+    # max number of cached entries for impressions
+    #
+    # @return [int] max numbre of entries
+    attr_accessor :max_number_of_keys
+
+    #
+    # initializes the class
+    #
+    # @param max [int] max number of cached entries
+    def initialize(max)
+      @queue = Queue.new
+      @max_number_of_keys = max
+    end
+
+    #
+    # generates a new entry for impressions list
+    #
+    # @param id [string] user key
+    # @param feature [string] feature name
+    # @param treatment [string] treatment value
+    # @param time [time] time value in milisenconds
+    #
+    # @return void
+    def log(id, feature, treatment, time)
+      impressions = KeyImpressions.new(id, treatment, time)
+      @queue << {feature: feature, impressions: impressions}
+    end
+
+    #
+    # clears the impressions queue
+    #
+    # @returns void
+    def clear
+      popped_impressions = []
+      begin
+        loop do
+          impression_element = @queue.pop(true)
+          feature_hash = popped_impressions.find { |i| i[:feature] == impression_element[:feature] }
+          if feature_hash.nil?
+            popped_impressions << {feature: impression_element[:feature], impressions: [] << impression_element[:impressions]}
+          else
+            feature_hash[:impressions] << impression_element[:impressions]
+          end
+        end
+      rescue ThreadError
+      end
+      popped_impressions
+    end
+
+  end
+
+  #
+  # small class to use as DTO for impressions
+  #
+  class KeyImpressions
+    attr_accessor :key
+    attr_accessor :treatment
+    attr_accessor :time
+
+    def initialize(key, treatment, time)
+      @key = key
+      @treatment = treatment
+      @time = time
+    end
+  end
+
+end

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

@@ -0,0 +1,46 @@
+module SplitIoClient
+
+  #
+  # class to implement the all keys matcher
+  #
+  class AllKeysMatcher < NoMethodError
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] true for all instances
+    def match?(key)
+      true
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif self.equal?(obj)
+        true
+      elsif !obj.instance_of?(AllKeysMatcher)
+        false
+      else
+        true
+      end
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      'in segment all'
+    end
+
+  end
+
+end

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

@@ -0,0 +1,13 @@
+module SplitIoClient
+
+  #
+  # class to represent combiner values
+  #
+  class Combiners < NoMethodError
+
+    # available combiners of the sdk
+    AND = 'AND'
+
+  end
+
+end

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

@@ -0,0 +1,94 @@
+require 'splitclient-engine/matchers/combiners'
+
+module SplitIoClient
+  #
+  # class to implement the combining matcher
+  #
+  class CombiningMatcher < NoMethodError
+
+    #
+    # list of matcher within the combiner
+    #
+    @matcher_list = []
+
+    #
+    # combiner value
+    #
+    @combiner = ''
+
+    def initialize(combiner, delegates)
+      unless delegates.nil?
+        @matcher_list = delegates
+      end
+      unless combiner.nil?
+        @combiner = combiner
+      end
+    end
+
+    #
+    # evaluates if the key matches the matchers within the combiner
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] match value for combiner delegates
+    def match?(key)
+      if @matcher_list.empty?
+        return false
+      end
+
+      case @combiner
+        when Combiners::AND
+          return and_eval(key)
+        else
+          #throws error
+      end
+    end
+
+    #
+    # auxiliary method to evaluate each of the matchers within the combiner
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] match value for combiner delegates
+    def and_eval(key)
+      result = true
+      @matcher_list.each do |delegate|
+        result &= (delegate.match?(key))
+      end
+      result
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(CombiningMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      result = ''
+      @matcher_list.each_with_index do |matcher, i|
+        result += matcher.to_s
+        result += ' ' + @combiner if i != 0
+      end
+      result
+    end
+
+  end
+
+end

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

@@ -0,0 +1,54 @@
+module SplitIoClient
+
+  #
+  # class to implement the negation of a matcher
+  #
+  class NegationMatcher < NoMethodError
+
+    @matcher = nil
+
+    def initialize(matcher)
+      unless matcher.nil?
+        @matcher = matcher
+      end
+    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?(key)
+      !@matcher.match?(key)
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(NegationMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      'not ' + @matcher.to_s
+    end
+
+  end
+
+end

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

@@ -0,0 +1,58 @@
+module SplitIoClient
+
+  #
+  # class to implement the user defined matcher
+  #
+  class UserDefinedSegmentMatcher < NoMethodError
+
+    @segment = nil
+
+    def initialize(segment)
+      unless segment.nil?
+        @segment = segment
+      end
+    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?(key)
+      matches = false
+      unless @segment.users.nil?
+        matches = @segment.users.include?(key)
+      end
+      matches
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(UserDefinedSegmentMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      'in segment ' + @segment.name
+    end
+
+  end
+
+end