kameleoon-client-ruby 1.1.2 → 2.0.0

data/lib/kameleoon/configuration/experiment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'kameleoon/targeting/models'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # Class for manage all experiments and old feature flags
+    class Experiment
+      attr_accessor :id, :status, :site_enabled, :deviations, :respool_time, :variations, :targeting_segment
+
+      def self.create_from_array(array)
+        array&.map { |it| Experiment.new(it) }
+      end
+
+      def initialize(experiment_hash)
+        @id = experiment_hash['id']
+        @status = experiment_hash['status']
+        @site_enabled = experiment_hash['siteEnabled']
+        unless experiment_hash['deviations'].nil?
+          @deviations =
+            Hash[*experiment_hash['deviations'].map do |it|
+              [it['variationId'] == 'origin' ? '0' : it['variationId'], it['value']]
+            end.flatten]
+        end
+        unless experiment_hash['respoolTime'].nil?
+          @respool_time =
+            Hash[*experiment_hash['respoolTime'].map do |it|
+              [it['variationId'] == 'origin' ? '0' : it['variationId'], it['value']]
+            end.flatten]
+        end
+        unless experiment_hash['variations'].nil?
+          @variations =
+          experiment_hash['variations'].map do |it|
+              { 'id' => it['id'].to_i, 'customJson' => it['customJson'] }
+            end
+        end
+        @targeting_segment = Kameleoon::Targeting::Segment.new((experiment_hash['segment'])) if experiment_hash['segment']
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/feature_flag.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'experiment'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # Class for manage all experiments and old feature flags
+    class FeatureFlag < Experiment
+      STATUS_ACTIVE = 'ACTIVE'
+      FEATURE_STATUS_DEACTIVATED = 'DEACTIVATED'
+      attr_accessor :identification_key, :feature_status, :schedules, :exposition_rate
+
+      def self.create_from_array(array)
+        array&.map { |it| FeatureFlag.new(it) }
+      end
+
+      def initialize(feature_flag_hash)
+        super(feature_flag_hash)
+        @feature_status = feature_flag_hash['featureStatus']
+        @identification_key = feature_flag_hash['identificationKey'] if feature_flag_hash['identificationKey']
+        @exposition_rate = feature_flag_hash['expositionRate']
+        @schedules = feature_flag_hash['schedules'] unless feature_flag_hash['schedules'].nil?
+      end
+
+      def is_scheduled_active(date)
+        current_status = @status == STATUS_ACTIVE
+        if @feature_status == FEATURE_STATUS_DEACTIVATED || @schedules.empty?
+          return current_status
+        end
+        @schedules.each do |schedule|
+          if (schedule['dateStart'].nil? || Time.parse(schedule['dateStart']).to_i < date) &&
+             (schedule['dateEnd'].nil? || Time.parse(schedule['dateEnd']).to_i > date)
+            return true
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/feature_flag_v2.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'rule'
+require_relative 'variation'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # Class for manage all feature flags v2 with rules
+    class FeatureFlagV2
+      attr_accessor :id, :feature_key, :variations, :default_variation_key, :rules
+
+      def self.create_from_array(array)
+        array&.map { |it| FeatureFlagV2.new(it) }
+      end
+
+      def initialize(hash)
+        @id = hash['id']
+        @feature_key = hash['featureKey']
+        @default_variation_key = hash['defaultVariationKey']
+        @variations = Variation.create_from_array(hash['variations'])
+        @rules = Rule.create_from_array(hash['rules'])
+      end
+
+      def get_variation_key(key)
+        variations.select { |v| v.key == key }.first
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/rule.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'variation_exposition'
+require 'kameleoon/targeting/models'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # RuleType has a possible rule types
+    module RuleType
+      EXPERIMENTATION = 'EXPERIMENTATION'
+      TARGETED_DELIVERY = 'TARGETED_DELIVERY'
+    end
+
+    # Rule is a class for new rules of feature flags
+    class Rule
+      attr_accessor :type, :exposition, :experiment_id, :variation_by_exposition, :targeting_segment
+
+      def self.create_from_array(array)
+        array&.map { |it| Rule.new(it) }
+      end
+
+      def initialize(hash)
+        @type = hash['type']
+        @exposition = hash['exposition']
+        @experiment_id = hash['experimentId']
+        @variation_by_exposition = VariationByExposition.create_from_array(hash['variationByExposition'])
+        @targeting_segment = Kameleoon::Targeting::Segment.new((hash['segment'])) if hash['segment']
+      end
+
+      def get_variation_key(hash_double)
+        total = 0.0
+        variation_by_exposition.each do |element|
+          total += element.exposition
+          return element.variation_key if total >= hash_double
+        end
+        nil
+      end
+
+      def get_variation_id_by_key(key)
+        variation_by_exposition.select { |v| v.variation_key == key }.first&.variation_id
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/variable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'experiment'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # Variable class contains key / type / value of variable
+    class Variable
+      attr_accessor :key, :type, :value
+
+      def self.create_from_array(array)
+        array&.map { |it| Variable.new(it) }
+      end
+
+      def initialize(hash)
+        @key = hash['key']
+        @type = hash['type']
+        @value = hash['value']
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/variation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'variable'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # Constant values of types of variations
+    module VariationType
+      VARIATION_OFF = 'off'
+    end
+
+    # Variation of feature flag
+    class Variation
+      attr_accessor :key, :variables
+
+      def self.create_from_array(array)
+        array&.map { |it| Variation.new(it) }
+      end
+
+      def initialize(hash)
+        @key = hash['key']
+        @variables = Variable.create_from_array(hash['variables'])
+      end
+
+      def get_variable_by_key(key)
+        variables.select { |var| var.key == key }.first
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/variation_exposition.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'experiment'
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # VariationByExposition represents a variation with exposition rate for rule
+    class VariationByExposition
+      attr_accessor :variation_key, :variation_id, :exposition
+
+      def self.create_from_array(array)
+        array&.map { |it| VariationByExposition.new(it) }
+      end
+
+      def initialize(hash)
+        @variation_key = hash['variationKey']
+        @variation_id = hash['variationId']
+        @exposition = hash['exposition']
+      end
+    end
+  end
+end

data/lib/kameleoon/cookie.rb

@@ -23,12 +23,19 @@ module Kameleoon
     end
 
     def obtain_hash_double(visitor_code, respool_times = {}, container_id = '')
+      obtain_hash_double_helper(visitor_code, respool_times, container_id, '')
+    end
+
+    def obtain_hash_double_v2(visitor_code, container_id = '', suffix = '')
+      obtain_hash_double_helper(visitor_code, {}, container_id, suffix)
+    end
+
+    def obtain_hash_double_helper(visitor_code, respool_times, container_id, suffix)
       identifier = visitor_code.to_s
       identifier += container_id.to_s
-      if !respool_times.nil? && !respool_times.empty?
-        identifier += respool_times.sort.to_h.values.join.to_s
-      end
-      (Digest::SHA256.hexdigest(identifier.encode('UTF-8')).to_i(16) / (BigDecimal("2") ** BigDecimal("256"))).round(16)
+      identifier += suffix.to_s
+      identifier += respool_times.sort.to_h.values.join.to_s if !respool_times.nil? && !respool_times.empty?
+      (Digest::SHA256.hexdigest(identifier.encode('UTF-8')).to_i(16) / (BigDecimal('2')**BigDecimal('256'))).round(16)
     end
     
     def check_visitor_code(visitor_code) 

data/lib/kameleoon/data.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Kameleoon
   NONCE_LENGTH = 16
 
   module DataType
-    CUSTOM = "CUSTOM"
-    BROWSER = "BROWSER"
-    CONVERSION = "CONVERSION"
-    INTEREST = "INTEREST"
-    PAGE_VIEW = "PAGE_VIEW"
+    CUSTOM = 'CUSTOM'
+    BROWSER = 'BROWSER'
+    CONVERSION = 'CONVERSION'
+    DEVICE = 'DEVICE'
+    PAGE_VIEW = 'PAGE_VIEW'
   end
 
   module BrowserType
@@ -18,6 +20,12 @@ module Kameleoon
     OTHER = 5
   end
 
+  module DeviceType
+    PHONE = 'PHONE'
+    TABLET = 'TABLET'
+    DESKTOP = 'DESKTOP'
+  end
+
   class Data
     attr_accessor :instance, :sent
 
@@ -89,7 +97,7 @@ module Kameleoon
 
     def obtain_full_post_text_line
       nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=staticData&browser=" + @browser.to_s + "&nonce=" + nonce
+      "eventType=staticData&browserIndex=" + @browser.to_s + "&nonce=" + nonce
     end
   end
 
@@ -98,22 +106,22 @@ module Kameleoon
 
     # @param [String] url Url of the page
     # @param [String] title Title of the page
-    # @param [Integer] referrer Optional field - Referrer id
-    def initialize(url, title, referrer = nil)
+    # @param [Array] referrers Optional field - Referrer ids
+    def initialize(url, title, referrers = nil)
       @instance = DataType::PAGE_VIEW
       @sent = false
       @url = url
       @title = title
-      @referrer = referrer
+      @referrers = referrers
     end
 
     def obtain_full_post_text_line
       nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      referrer_text = ""
-      unless @referrer.nil?
-        referrer_text = "&referrers=[" + @referrer.to_s + "]"
+      referrer_text = ''
+      unless @referrers.nil?
+        referrer_text = "&referrersIndices=" + @referrers.to_s
       end
-      "eventType=page&href=" + encode(@url) + "&title=" + @title + "&keyPages=[]" + referrer_text + "&nonce=" + nonce
+      "eventType=page&href=" + encode(@url) + "&title=" + @title + referrer_text + "&nonce=" + nonce
     end
   end
 
@@ -137,19 +145,25 @@ module Kameleoon
     end
   end
 
-  class Interest < Data
-    attr_accessor :index
-
-    # @param [Integer] index Index of the interest
-    def initialize(index)
-      @instance = DataType::INTEREST
+  # Device uses for sending deviceType parameter for tracking calls
+  class Device < Data
+    def initialize(device_type)
+      @instance = DataType::DEVICE
       @sent = false
-      @index = index
+      @device_type = device_type
     end
 
     def obtain_full_post_text_line
       nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=interests&indexes=[" + @index.to_s + "]&fresh=true&nonce=" + nonce
+      "eventType=staticData&deviceType=#{@device_type}&nonce=#{nonce}"
+    end
+  end
+
+  # UserAgent uses for changing User-Agent header for tracking calls
+  class UserAgent
+    attr_accessor :value
+    def initialize(value)
+      @value = value
     end
   end
-end
+end

data/lib/kameleoon/exceptions.rb

@@ -1,59 +1,82 @@
+# frozen_string_literal: true
+
 module Kameleoon
   module Exception
+    # Base Error
     class KameleoonError < ::StandardError
       def initialize(message = nil)
-        super("Kameleoon error: " + message)
+        super("Kameleoon error: #{message}")
       end
     end
+
+    # Base Not Found Error
     class NotFound < KameleoonError
-      def initialize(value = "")
-        super(value.to_s + " not found.")
+      def initialize(value = '')
+        super("#{value} not found.")
       end
     end
+
+    # Variation Not Found
     class VariationConfigurationNotFound < NotFound
-      def initialize(id = "")
-        super("Variation " + id.to_s)
+      def initialize(id = '')
+        super("Variation #{id}")
       end
     end
-    class ExperimentConfigurationNotFound	 < NotFound
-      def initialize(id = "")
-        super("Experiment " + id.to_s)
+
+    # Experiment Configuration Not Found
+    class ExperimentConfigurationNotFound	< NotFound
+      def initialize(id = '')
+        super("Experiment #{id}")
       end
     end
+
+    # Feature Flag Configuration Not Found
     class FeatureConfigurationNotFound < NotFound
-      def initialize(id = "")
-        super("Feature flag " + id.to_s)
+      def initialize(id = '')
+        super("Feature flag #{id}")
       end
     end
+
+    # Feature Variable Not Found
     class FeatureVariableNotFound < NotFound
-      def initialize(key = "")
-        super("Feature variable " + key.to_s)
+      def initialize(key = '')
+        super("Feature variable #{key}")
       end
     end
+
+    # Credentials Not Found
     class CredentialsNotFound < NotFound
       def initialize
-        super("Credentials")
+        super('Credentials')
       end
     end
+
+    # Not Targeted (when visitor is not targeted for experiment or feature flag)
     class NotTargeted < KameleoonError
-      def initialize(visitor_code = "")
-        super("Visitor " + visitor_code + " is not targeted.")
+      def initialize(visitor_code = '')
+        super("Visitor #{visitor_code} is not targeted.")
       end
     end
-    class NotActivated < KameleoonError
-      def initialize(visitor_code = "")
-        super("Visitor " + visitor_code + " is not activated.")
+
+    # Not Allocated (when visitor is not allocated for experiment)
+    class NotAllocated < KameleoonError
+      def initialize(visitor_code = '')
+        super("Visitor #{visitor_code} is not targeted.")
       end
     end
+
+    # Visitor Code Not Valod (empty or length > 255)
     class VisitorCodeNotValid < KameleoonError
-      def initialize(message = "")
-        super("Visitor code not valid: " + message)
+      def initialize(message = '')
+        super("Visitor code not valid: #{message}")
       end
     end
+
+    # SiteCode Disabled
     class SiteCodeDisabled < KameleoonError
-      def initialize(message = "")
-        super("Site with siteCode '" + message + "' is disabled")
+      def initialize(message = '')
+        super("Site with siteCode '#{message}' is disabled")
       end
     end
   end
-end
+end

data/lib/kameleoon/factory.rb

@@ -1,26 +1,29 @@
+# frozen_string_literal: true
+
 require 'kameleoon/client'
 
 module Kameleoon
+  # A Factory class for creating kameleoon clients
   module ClientFactory
     CONFIGURATION_UPDATE_INTERVAL = '60m'
-    CONFIG_PATH = "/etc/kameleoon/client-ruby.yaml"
-    DEFAULT_TIMEOUT = 2000 #milli-seconds
+    CONFIG_PATH = '/etc/kameleoon/client-ruby.yaml'
+    DEFAULT_TIMEOUT = 2000 # milli-seconds
+
+    @clients = {}
+
+    def self.create(site_code, config_path = CONFIG_PATH, client_id = nil, client_secret = nil)
+      if @clients[site_code].nil?
+        client = Client.new(site_code, config_path, CONFIGURATION_UPDATE_INTERVAL,
+                            DEFAULT_TIMEOUT, client_id, client_secret)
+        client.send(:log, "Client created with site code: #{site_code}")
+        client.send(:fetch_configuration)
+        @clients.store(site_code, client)
+      end
+      @clients[site_code]
+    end
 
-    ##
-    # Create a kameleoon client object, each call create a new client.
-    # The starting point for using the SDK is the initialization step. All interaction with the SDK is done through an object of the Kameleoon::Client class, therefore you need to create this object via Kameleoon::ClientFactory create static method.
-    #
-    # @param [String] site_code Site code
-    # @param [Boolean] blocking - optional, default is false
-    #
-    # @return [Kameleoon::Client]
-    #
-    def self.create(site_code, blocking = false, config_path = CONFIG_PATH, client_id = nil, client_secret = nil)
-      client = Client.new(site_code, config_path, blocking, CONFIGURATION_UPDATE_INTERVAL, DEFAULT_TIMEOUT, client_id, client_secret)
-      client.send(:log, "Warning: you are using the blocking mode") if blocking
-      client.send(:log, "Client created with site code: " + site_code.to_s)
-      client.send(:fetch_configuration)
-      client
+    def self.forget(site_code)
+      @clients.delete(site_code)
     end
   end
-end
+end

data/lib/kameleoon/request.rb

@@ -1,16 +1,18 @@
-require "em-synchrony/em-http"
-require "kameleoon/version"
+require 'em-synchrony/em-http'
+require 'kameleoon/version'
 require 'net/http'
 
 module Kameleoon
   # @api private
   module Request
     protected
-    API_URL = "https://api.kameleoon.com"
+
+    API_URL = 'https://api.kameleoon.com'.freeze
+    CLIENT_CONFIG_URL = 'https://client-config.kameleoon.com'.freeze
 
     module Method
-      GET = "get"
-      POST = "post"
+      GET = 'get'.freeze
+      POST = 'post'.freeze
     end
 
     def get(request_options, url = API_URL, connexion_options = {})
@@ -32,7 +34,7 @@ module Kameleoon
     private
 
     def request(method, request_options, url, connexion_options)
-      connexion_options[:tls] = {verify_peer: false}
+      connexion_options[:tls] = { verify_peer: false }
       add_user_agent(request_options)
       case method
         when Method::POST then
@@ -40,7 +42,7 @@ module Kameleoon
         when Method::GET then
           return EventMachine::HttpRequest.new(url, connexion_options).get request_options
         else
-          print "Unknown request type"
+          print 'Unknown request type'
           return false
       end
     end
@@ -68,22 +70,21 @@ module Kameleoon
       end
     end
 
-    def is_successful(request)
+    def successful?(request)
       !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
     end
 
-    def is_successful_sync(response)
+    def successful_sync?(response)
       !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
     end
 
     def add_user_agent(request_options)
+      sdk_version = "sdk/ruby/#{Kameleoon::VERSION}"
       if request_options[:head].nil?
-        request_options[:head] = {'Kameleoon-Client' => 'sdk/ruby/' + Kameleoon::VERSION}
+        request_options[:head] = { 'Kameleoon-Client' => sdk_version }
       else
-        request_options[:head].store('Kameleoon-Client', 'sdk/ruby/' + Kameleoon::VERSION)
+        request_options[:head].store('Kameleoon-Client', sdk_version)
       end
     end
   end
 end
-
-

data/lib/kameleoon/storage/variation_storage.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'kameleoon/storage/visitor_variation'
+
+module Kameleoon
+  module Storage
+    # VariationStorage is a container for saved variations associated with a visitor
+    class VariationStorage
+      def initialize
+        @storage = {}
+      end
+
+      def get_variation_id(visitor_code, experiment_id)
+        variation_valid?(visitor_code, experiment_id, nil)
+      end
+
+      def variation_valid?(visitor_code, experiment_id, respool_time)
+        return nil if @storage[visitor_code].nil? || @storage[visitor_code][experiment_id].nil?
+
+        variation = @storage[visitor_code][experiment_id]
+        return nil unless variation.valid?(respool_time)
+
+        variation.variation_id
+      end
+
+      def update_variation(visitor_code, experiment_id, variation_id)
+        @storage[visitor_code] = {} if @storage[visitor_code].nil?
+        @storage[visitor_code][experiment_id] = Kameleoon::Storage::VisitorVariation.new(variation_id)
+      end
+
+      def get_hash_saved_variation_id(visitor_code)
+        return nil if @storage[visitor_code].nil?
+
+        map_variations = {}
+        @storage[visitor_code].each do |key, value|
+          map_variations[key] = value.variation_id
+        end
+        map_variations
+      end
+    end
+  end
+end

data/lib/kameleoon/storage/visitor_variation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Storage
+    # VisitorVariation contains a saved variation id associated with a visitor
+    # and time when it was associated.
+    class VisitorVariation
+      attr_accessor :variation_id
+
+      def initialize(variation_id)
+        @variation_id = variation_id
+        @assignment_date = Time.now.to_i
+      end
+
+      def valid?(respool_time)
+        respool_time.nil? || @assignment_date > respool_time
+      end
+    end
+  end
+end