kameleoon-client-ruby 2.0.0 → 2.1.1

data/lib/kameleoon/configuration/feature_flag.rb

@@ -1,40 +1,29 @@
 # frozen_string_literal: true
 
-require_relative 'experiment'
+require_relative 'rule'
+require_relative 'variation'
 
 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
+    # Class for manage all feature flags with rules
+    class FeatureFlag
+      attr_accessor :id, :feature_key, :variations, :default_variation_key, :rules
 
       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?
+      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 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
+      def get_variation_key(key)
+        variations.select { |v| v.key == key }.first
       end
     end
   end

data/lib/kameleoon/configuration/rule.rb

@@ -14,25 +14,29 @@ module Kameleoon
 
     # Rule is a class for new rules of feature flags
     class Rule
-      attr_accessor :type, :exposition, :experiment_id, :variation_by_exposition, :targeting_segment
+      attr_reader :id, :order, :type, :exposition, :experiment_id, :variation_by_exposition, :respool_time
+      attr_accessor :targeting_segment
 
       def self.create_from_array(array)
         array&.map { |it| Rule.new(it) }
       end
 
       def initialize(hash)
+        @id = hash['id']
+        @order = hash['order']
         @type = hash['type']
         @exposition = hash['exposition']
         @experiment_id = hash['experimentId']
+        @respool_time = hash['respoolTime']
         @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)
+      def get_variation(hash_double)
         total = 0.0
-        variation_by_exposition.each do |element|
-          total += element.exposition
-          return element.variation_key if total >= hash_double
+        variation_by_exposition.each do |var_by_exp|
+          total += var_by_exp.exposition
+          return var_by_exp if total >= hash_double
         end
         nil
       end
@@ -40,6 +44,14 @@ module Kameleoon
       def get_variation_id_by_key(key)
         variation_by_exposition.select { |v| v.variation_key == key }.first&.variation_id
       end
+
+      def experimentation_type?
+        @type == RuleType::EXPERIMENTATION
+      end
+
+      def targeted_delivery_type?
+        @type == RuleType::TARGETED_DELIVERY
+      end
     end
   end
 end

data/lib/kameleoon/configuration/settings.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+    # KameleoonConfigurationSettings is used for saving setting's parameters, e.g
+    # state of real time update for site code and etc
+    class Settings
+      attr_accessor :real_time_update
+
+      def initialize
+        @real_time_update = false
+      end
+
+      def update(configuration)
+        @real_time_update = configuration['realTimeUpdate'] || false
+      end
+    end
+  end
+end

data/lib/kameleoon/cookie.rb

@@ -26,7 +26,7 @@ module Kameleoon
       obtain_hash_double_helper(visitor_code, respool_times, container_id, '')
     end
 
-    def obtain_hash_double_v2(visitor_code, container_id = '', suffix = '')
+    def obtain_hash_double_rule(visitor_code, container_id = '', suffix = '')
       obtain_hash_double_helper(visitor_code, {}, container_id, suffix)
     end
 
@@ -37,8 +37,8 @@ module Kameleoon
       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) 
+
+    def check_visitor_code(visitor_code)
       if visitor_code.nil?
         check_default_visitor_code('')
       elsif

data/lib/kameleoon/data/browser.rb

@@ -0,0 +1,33 @@
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  module BrowserType
+    CHROME = 0
+    INTERNET_EXPLORER = 1
+    FIREFOX = 2
+    SAFARI = 3
+    OPERA = 4
+    OTHER = 5
+  end
+
+  # Represents browser data for tracking calls
+  class Browser < Data
+    attr_reader :type, :version
+
+    # @param [BrowserType] browser_type Browser type, can be: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER
+    # @param [float] version Version of browser
+    def initialize(browser_type, version = Float::NAN)
+      super(DataType::BROWSER)
+      @type = browser_type
+      @version = version
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      url = "eventType=staticData&browserIndex=#{@type}&nonce=#{nonce}"
+      url.concat("&browserVersion=#{@version}") if @version.is_a?(Integer) || (@version.is_a?(Float) && !@version.nan?)
+      url
+    end
+  end
+end

data/lib/kameleoon/data/conversion.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Conversion class uses for tracking conversion
+  class Conversion < Data
+    attr_reader :goal_id, :revenue, :negative
+
+    # @param [Integer] goal_id Id of the goal associated to the conversion
+    # @param [Float] revenue Optional field - Revenue associated to the conversion.
+    # @param [Boolean] negative Optional field - If the revenue is negative. By default it's positive.
+    def initialize(goal_id, revenue = 0.0, negative = false)
+      super(DataType::CONVERSION)
+      @goal_id = goal_id
+      @revenue = revenue || 0.0
+      @negative = negative || false
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=conversion&goalId=#{@goal_id}&revenue=#{@revenue}&negative=#{@negative}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/custom_data.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Represents any custom data for targeting conditions
+  class CustomData < Data
+    attr_reader :id, :values
+
+    # @param [Integer] id Id of the custom data
+    # @param [String] value Value of the custom data
+    # @param [Array] values Array of values of the custom data
+    #
+    # @overload
+    # @param [Hash] hash Json value encoded in a hash.
+    # rubocop:disable Metrics/MethodLength
+    def initialize(arg0, *args)
+      super(DataType::CUSTOM)
+      if arg0.is_a?(Hash)
+        hash = arg0
+        id = hash['id']
+        raise Kameleoon::Exception::NotFound.new('id'), '"id" is mandatory' if id.nil?
+
+        @id = id.to_s
+        value = hash['value']
+        values = hash['values']
+        if values.nil? && value.nil?
+          raise Kameleoon::Exception::NotFound.new('value or values'), '"value" or "values" is mandatory'
+        end
+
+        if values.nil?
+          @values = [value]
+        else
+          @values = values.is_a?(Array) ? values.dup : [values]
+          @values.append(value) unless value.nil?
+        end
+      else
+        @id = arg0.to_s
+        @values = args
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def obtain_full_post_text_line
+      return '' if @values.empty?
+
+      str_values = JSON.generate(Hash[@values.collect { |k| [k, 1] }])
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=customData&index=#{@id}&valuesCountMap=#{self.class.encode(str_values)}&overwrite=true&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/data.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  NONCE_LENGTH = 16
+
+  module DataType
+    CUSTOM = 'CUSTOM'
+    BROWSER = 'BROWSER'
+    CONVERSION = 'CONVERSION'
+    DEVICE = 'DEVICE'
+    PAGE_VIEW = 'PAGE_VIEW'
+  end
+
+  # Represents base class for any Kameleoon data
+  class Data
+    attr_reader :instance
+    attr_accessor :sent
+
+    def initialize(data_type)
+      @instance = data_type
+      @sent = false
+    end
+
+    def obtain_full_post_text_line
+      raise KameleoonError.new('ToDo: implement this method.'), 'ToDo: implement this method.'
+    end
+
+    def self.encode(url)
+      Network::UriHelper.encode_uri(url)
+    end
+  end
+end

data/lib/kameleoon/data/device.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  module DeviceType
+    PHONE = 'PHONE'
+    TABLET = 'TABLET'
+    DESKTOP = 'DESKTOP'
+  end
+
+  # Device uses for sending deviceType parameter for tracking calls
+  class Device < Data
+    attr_reader :device_type
+    def initialize(device_type)
+      super(DataType::DEVICE)
+      @device_type = device_type
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=staticData&deviceType=#{@device_type}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/page_view.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Represents page view data for tracking calls
+  class PageView < Data
+    attr_reader :url, :title, :referrer
+
+    # @param [String] url Url of the page
+    # @param [String] title Title of the page
+    # @param [Array] referrers Optional field - Referrer ids
+    def initialize(url, title, referrers = nil)
+      super(DataType::PAGE_VIEW)
+      @url = url || ''
+      @title = title || ''
+      @referrers = referrers.instance_of?(Integer) ? [referrers] : referrers
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      referrer_text = if !@referrers.nil? && !@referrers.empty?
+                        "&referrersIndices=%5B#{@referrers.each(&:to_s).join('%2C')}%5D"
+                      else
+                        ''
+                      end
+      "eventType=page&href=#{self.class.encode(@url)}&title=#{self.class.encode(@title)}#{referrer_text}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/user_agent.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kameleoon
+  # UserAgent uses for changing User-Agent header for tracking calls
+  class UserAgent
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/kameleoon/hybrid/manager.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Hybrid
+    TC_INIT = 'window.kameleoonQueue=window.kameleoonQueue||[];'
+    TC_ASSIGN_VARIATION_FORMAT = "window.kameleoonQueue.push(['Experiments.assignVariation',%d,%d]);"
+    TC_TRIGGER_FORMAT = "window.kameleoonQueue.push(['Experiments.trigger',%d,true]);"
+    TC_ASSIGN_VARIATION_TRIGGER_FORMAT = TC_ASSIGN_VARIATION_FORMAT + TC_TRIGGER_FORMAT
+
+    # Will be useful for Ruby 3.0
+    # Abstract Manager class (interface)
+    class Manager
+      def add_variation(_visitor, _experiment_id, _variation_id)
+        raise 'Abstract method `add` called'
+      end
+
+      def get_engine_tracking_code(_visitor)
+        raise 'Abstract method `get_engine_tracking_code` called'
+      end
+    end
+
+    # Implementation of Cache with auto cleaning feature
+    class ManagerImpl < Manager
+      def initialize(expiration_time, cleaning_interval, cache_factory, log_func)
+        super()
+        # synchronization is necessary for adding same visitor_code from different threads
+        @mutex = Mutex.new
+        @expiration_time = expiration_time
+        @cache_factory = cache_factory
+        @log = log_func
+        # it's recommend to use cleaning_interval 3-4 times more than experiation_time for more performance
+        # in this case on every cleaning iteration storage will be cleaned 2/3 - 3/4 of volume
+        @cache = cache_factory.create(expiration_time, cleaning_interval)
+        @log.call('Hybrid Manager was successfully initialized')
+      end
+
+      def add_variation(visitor_code, experiment_id, variation_id)
+        @mutex.synchronize do
+          visitor_cache = @cache.get(visitor_code)
+          visitor_cache = @cache_factory.create(@expiration_time, 0) if visitor_cache.nil?
+          visitor_cache.set(experiment_id, variation_id)
+          @cache.set(visitor_code, visitor_cache)
+        end
+        @log.call("Hybrid Manager successfully added variation for visitor_code: #{visitor_code}, " \
+          "experiment: #{experiment_id}, variation: #{variation_id}")
+      end
+
+      def get_engine_tracking_code(visitor_code)
+        tracking_code = TC_INIT
+        visitor_cache = @cache.get(visitor_code)
+        return tracking_code if visitor_cache.nil?
+
+        visitor_cache.active_items.each_pair do |key, value|
+          tracking_code += format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, key, value, key)
+        end
+        tracking_code
+      end
+    end
+  end
+end

data/lib/kameleoon/network/activity_event.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'kameleoon/data/data'
+require 'kameleoon/utils'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # ActivityEvent represents an activity tracking event.
+    class ActivityEvent
+      EVENT_TYPE = 'activity'
+
+      attr_accessor :sent
+
+      def initialize
+        @sent = false
+        @nonce = Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)
+      end
+
+      def obtain_full_post_text_line
+        params = {
+          eventType: EVENT_TYPE,
+          nonce: @nonce
+        }
+        UriHelper.encode_query(params)
+      end
+    end
+  end
+end

data/lib/kameleoon/network/experiment_event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'kameleoon/data/data'
+require 'kameleoon/utils'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # ExperimentEvent represents an experiment tracking event.
+    class ExperimentEvent
+      EVENT_TYPE = 'experiment'
+
+      attr_accessor :sent
+
+      def initialize(experiment_id, variation_id)
+        @sent = false
+        @experiment_id = experiment_id
+        @variation_id = variation_id
+        @nonce = Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)
+      end
+
+      def obtain_full_post_text_line
+        params = {
+          eventType: EVENT_TYPE,
+          id: @experiment_id,
+          variationId: @variation_id,
+          nonce: @nonce
+        }
+        UriHelper.encode_query(params)
+      end
+    end
+  end
+end

data/lib/kameleoon/network/uri_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'uri'
+
+module Kameleoon
+  module Network
+    ##
+    # UriHelper contains functions which helps working with URIs.
+    module UriHelper
+      def self.encode_uri(uri)
+        encoded = CGI.escape(uri)
+        encoded.gsub!(/%21|%27|%28|%29|%2A|\+/,
+                      '%21' => '!',
+                      '%27' => "'",
+                      '%28' => '(',
+                      '%29' => ')',
+                      '%2A' => '*',
+                      '+' => '%20')
+        encoded
+      end
+
+      def self.encode_query(params)
+        encoded = URI.encode_www_form(params)
+        encoded.gsub!(/%21|%27|%28|%29|%7E|\+/,
+                      '%21' => '!',
+                      '%27' => "'",
+                      '%28' => '(',
+                      '%29' => ')',
+                      '%7E' => '~',
+                      '+' => '%20')
+        encoded
+      end
+    end
+  end
+end

data/lib/kameleoon/network/url_provider.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'kameleoon/version'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # UrlProvider is used as a source of URLs for network calls.
+    class UrlProvider
+      TRACKING_PATH = '/visit/events'
+      VISITOR_DATA_PATH = '/visit/visitor'
+      GET_DATA_PATH = '/map/map'
+      POST_DATA_PATH = '/map/maps'
+      CONFIGURATION_API_URL = 'https://client-config.kameleoon.com/mobile'
+      RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
+
+      DEFAULT_DATA_API_URL = 'https://data.kameleoon.io'
+      TEST_DATA_API_URL = 'https://data.kameleoon.net'
+
+      attr_reader :site_code, :data_api_url
+
+      def initialize(site_code, data_api_url)
+        @site_code = site_code
+        @data_api_url = data_api_url
+      end
+
+      def make_tracking_url(visitor_code)
+        params = {
+          sdkName: SDK_NAME,
+          sdkVersion: SDK_VERSION,
+          siteCode: @site_code,
+          visitorCode: visitor_code
+        }
+        "#{@data_api_url}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_visitor_data_get_url(visitor_code)
+        params = {
+          siteCode: @site_code,
+          visitorCode: visitor_code,
+          currentVisit: true,
+          maxNumberPreviousVisits: 1,
+          customData: true,
+          version: 0
+        }
+        "#{@data_api_url}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_api_data_get_request_url(key)
+        params = {
+          siteCode: @site_code,
+          key: key
+        }
+        "#{@data_api_url}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_configuration_url(environment = nil, timestamp = nil)
+        params = { siteCode: @site_code }
+        params[:environment] = environment unless environment.nil?
+        params[:ts] = timestamp unless timestamp.nil?
+        "#{CONFIGURATION_API_URL}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_real_time_url
+        params = { siteCode: @site_code }
+        "#{RT_CONFIGURATION_URL}?#{UriHelper.encode_query(params)}"
+      end
+    end
+  end
+end