kameleoon-client-ruby 3.1.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2ae21c547d82441a35f311ca195d4d0b15be760535eb2d2cd33763cdaa5d3f
-  data.tar.gz: ae9e41be3beda39be11c259d115d0543179e5b4a0549aa73b05c253d99cbd950
+  metadata.gz: '019ae7a1fe145f50f68beea1eb05bcae993d4061a2b1bdb2fe4324fc4215aa39'
+  data.tar.gz: fe9637047ba81b006c1b19a4c85e82fa5641a4d3f666fe14cb28ee243076b6ac
 SHA512:
-  metadata.gz: 8e99dc556e6f39202765a6ac8da2f0c0ccf3d6f7ebccee7996f9741d5608eb485d6802b1920aaa78f881b0f66d05c63d89102df75ed20853aae562fc87787cf5
-  data.tar.gz: 161950ca9c72591a7ffa59e82d231c01b478d504449557852b79570b97cb94cacf686033343275915653cc9f66cb9395563a542dc6955ed9b93354d4fa43c525
+  metadata.gz: 5455718dd4a68c584c280e4004ff1c96e28b35d7bfcd9bd8299c68b9d0f3930bd064e16057ce71bbfc386911f106839f54a6398165e6966cad5ce5a4388ccbe9
+  data.tar.gz: 7a2e231a4625c642a56354615999543c26d7e882d8fc7a2c743f7f4f045d01bc88d5dafd227757fd88f308053610f22f21bfa6cbadd79eafe2b7f2bc3a5e03b7

data/lib/kameleoon/configuration/custom_data_info.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # Module which contains all internal data of SDK
+  module Configuration
+
+    class CustomDataInfo
+      attr_reader :local_only, :visitor_scope, :mapping_identifier_index
+      SCOPE_VISITOR = 'VISITOR'
+
+      def initialize(hashes, log_func = nil)
+        @local_only = Set[]
+        @visitor_scope = Set[]
+        @log_func = log_func
+        unless hashes.nil?
+          for hash in hashes
+            index = hash['index']
+            @local_only.add(index) if hash['localOnly']
+            @visitor_scope.add(index) if hash['scope'] == SCOPE_VISITOR
+            if hash['isMappingIdentifier']
+              if @mapping_identifier_index != nil
+                @log_func&.call('More than one mapping identifier is set. Undefined behavior may occur on cross-device reconciliation.')
+              end
+              @mapping_identifier_index = index
+            end
+          end
+        end
+      end
+
+      def local_only? (index)
+        @local_only.include?(index)
+      end
+
+      def mapping_identifier? (index)
+        index == @mapping_identifier_index
+      end
+
+      def visitor_scope? (index)
+        @visitor_scope.include?(index)
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/data_file.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
 require 'kameleoon/configuration/settings'
+require 'kameleoon/configuration/feature_flag'
+require 'kameleoon/configuration/custom_data_info'
 
 module Kameleoon
   module Configuration
     class DataFile
-      attr_reader :settings, :feature_flags, :has_any_targeted_delivery_rule
+      attr_reader :settings, :feature_flags, :has_any_targeted_delivery_rule, :feature_flag_by_id, :rule_by_segment_id,
+                  :variation_by_id, :custom_data_info
 
-      def initialize(environment)
+      def initialize(environment, log_func = nil)
         @settings = Settings.new
         @feature_flags = {}
         @environment = environment
+        @log_func = log_func
+        collect_indices
+        @custom_data_info = Kameleoon::Configuration::CustomDataInfo.new(nil, @log_func)
       end
 
       def init(configuration)
@@ -20,6 +26,8 @@ module Kameleoon
           @feature_flags[ff.feature_key] = ff
         end
         @has_any_targeted_delivery_rule = any_targeted_delivery_rule?
+        collect_indices
+        @custom_data_info = CustomDataInfo.new(configuration['customData'], @log_func)
         self
       end
 
@@ -36,6 +44,27 @@ module Kameleoon
       def any_targeted_delivery_rule?
         @feature_flags.any? { |_, ff| ff.environment_enabled && ff.rules.any?(&:targeted_delivery_type?) }
       end
+
+      def collect_indices
+        @feature_flag_by_id = {}
+        @rule_by_segment_id = {}
+        @variation_by_id = {}
+
+        @feature_flags.each_value do |feature_flag|
+          @feature_flag_by_id[feature_flag.id] = feature_flag
+          next if feature_flag.rules.nil?
+
+          feature_flag.rules.each do |rule|
+            @rule_by_segment_id[rule.segment_id] = rule
+            rule.variation_by_exposition.each do |variation|
+              @variation_by_id[variation.variation_id] = variation
+            end
+          end
+        end
+        @feature_flag_by_id.freeze
+        @rule_by_segment_id.freeze
+        @variation_by_id.freeze
+      end
     end
   end
 end

data/lib/kameleoon/configuration/rule.rb

@@ -29,7 +29,7 @@ module Kameleoon
 
     # Rule is a class for new rules of feature flags
     class Rule
-      attr_reader :id, :order, :type, :exposition, :experiment_id, :variation_by_exposition, :respool_time
+      attr_reader :id, :order, :type, :exposition, :experiment_id, :variation_by_exposition, :respool_time, :segment_id, :first_variation
       attr_accessor :targeting_segment
 
       def self.create_from_array(array)
@@ -44,7 +44,10 @@ module Kameleoon
         @experiment_id = hash['experimentId']
         @respool_time = hash['respoolTime']
         @variation_by_exposition = VariationByExposition.create_from_array(hash['variationByExposition'])
+        @variation_by_exposition.freeze
+        @first_variation = @variation_by_exposition.first
         @targeting_segment = Kameleoon::Targeting::Segment.new((hash['segment'])) if hash['segment']
+        @segment_id = @targeting_segment != nil ? targeting_segment.id : -1
       end
 
       def get_variation(hash_double)

data/lib/kameleoon/configuration/variation_exposition.rb

@@ -5,7 +5,7 @@ module Kameleoon
   module Configuration
     # VariationByExposition represents a variation with exposition rate for rule
     class VariationByExposition
-      attr_accessor :variation_key, :variation_id, :exposition
+      attr_reader :variation_key, :variation_id, :exposition
 
       def self.create_from_array(array)
         array&.map { |it| VariationByExposition.new(it) }

data/lib/kameleoon/data/browser.rb

@@ -12,6 +12,25 @@ module Kameleoon
     SAFARI = 3
     OPERA = 4
     OTHER = 5
+
+    def self.from_name(name)
+      case name
+      when 'CHROME'
+        BrowserType::CHROME
+      when 'INTERNET_EXPLORER'
+        BrowserType::INTERNET_EXPLORER
+      when 'FIREFOX'
+        BrowserType::FIREFOX
+      when 'SAFARI'
+        BrowserType::SAFARI
+      when 'OPERA'
+        BrowserType::OPERA
+      when 'OTHER'
+        BrowserType::OTHER
+      else
+        nil
+      end
+    end
   end
 
   # Represents browser data for tracking calls

data/lib/kameleoon/data/cookie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # Cookie contains information about the cookie stored on the visitor's device
+  class Cookie
+    attr_reader :cookies
+
+    # @param [Hash] cookies
+    def initialize(cookies)
+      @cookies = cookies
+    end
+  end
+end
+

data/lib/kameleoon/data/custom_data.rb

@@ -8,6 +8,7 @@ module Kameleoon
   # Represents any custom data for targeting conditions
   class CustomData < DuplicationUnsafeData
     attr_reader :id, :values
+    attr_accessor :is_mapping_identifier
 
     # @param [Integer] id Id of the custom data
     # @param [String] value Value of the custom data
@@ -50,6 +51,7 @@ module Kameleoon
         overwrite: 'true',
         nonce: nonce
       }
+      params[:mappingIdentifier] = is_mapping_identifier if is_mapping_identifier
       Kameleoon::Network::UriHelper.encode_query(params)
     end
   end

data/lib/kameleoon/data/data.rb

@@ -14,6 +14,8 @@ module Kameleoon
     DEVICE = 'DEVICE'
     PAGE_VIEW = 'PAGE_VIEW'
     ASSIGNED_VARIATION = 'ASSIGNED_VARIATION'
+    OPERATING_SYSTEM = 'OPERATING_SYSTEM'
+    GEOLOCATION = 'GEOLOCATION'
   end
 
   # Represents base class for any Kameleoon data

data/lib/kameleoon/data/geolocation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # Geolocation contains the visitor's geolocation details
+  class Geolocation < DuplicationUnsafeData
+    attr_reader :country, :region, :city, :postal_code, :latitude, :longitude
+
+    # @param [String] country Country of visitor's geolocation. Required
+    # @param [String] region Region of visitor's geolocation. Optional
+    # @param [String] city City of visitor's geolocation. Optional
+    # @param [String] postal_code Postal code of visitor's geolocation. Optional
+    # @param [Float] latitude Latitude of visitor's geolocation. Optional
+    # @param [Float] longitude Longitude of visitor's geolocation. Optional
+    def initialize(country, region = nil, city = nil, postal_code = nil, latitude = Float::NAN, longitude = Float::NAN)
+      super(DataType::GEOLOCATION)
+      @country = country
+      @region = region
+      @city = city
+      @postal_code = postal_code
+      @latitude = latitude
+      @longitude = longitude
+    end
+
+    def obtain_full_post_text_line
+      params = {
+        eventType: 'staticData',
+        nonce: nonce
+      }
+      params[:country] = @country if @country.is_a?(String)
+      params[:region] = @region if @region.is_a?(String)
+      params[:city] = @city if @city.is_a?(String)
+      params[:postalCode] = @postal_code if @postal_code.is_a?(String)
+      params[:latitude] = @latitude if valid_number?(@latitude)
+      params[:longitude] = @longitude if valid_number?(@longitude)
+      Kameleoon::Network::UriHelper.encode_query(params)
+    end
+
+    private
+
+    def valid_number?(value)
+      value.is_a?(Integer) || (value.is_a?(Float) && !value.nan?)
+    end
+  end
+end
+

data/lib/kameleoon/data/kcs_heat.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  class KcsHeat
+    attr_reader :values
+
+    def initialize(values)
+      @values = values
+      @values.freeze
+    end
+  end
+end

data/lib/kameleoon/data/manager/assigned_variation.rb

@@ -2,6 +2,7 @@
 
 require 'kameleoon/data/data'
 require 'kameleoon/network/uri_helper'
+require 'kameleoon/configuration/rule'
 
 module Kameleoon
   module DataManager
@@ -12,7 +13,7 @@ module Kameleoon
 
       attr_reader :experiment_id, :variation_id, :rule_type, :assignment_time
 
-      def initialize(experiment_id, variation_id, rule_type, assignment_time: nil)
+      def initialize(experiment_id, variation_id, rule_type = Kameleoon::Configuration::RuleType::UNKNOWN, assignment_time: nil)
         super(DataType::ASSIGNED_VARIATION)
         @experiment_id = experiment_id
         @variation_id = variation_id

data/lib/kameleoon/data/manager/page_view_visit.rb

@@ -3,17 +3,31 @@
 module Kameleoon
   module DataManager
     class PageViewVisit
-      attr_reader :page_view, :count
+      attr_reader :page_view, :count, :last_timestamp
 
-      def initialize(page_view, count = 1)
+      def initialize(page_view, count = 1, timestamp = nil)
         @page_view = page_view
         @count = count
+        @last_timestamp = timestamp != nil ? timestamp : Time.new.to_i
       end
 
+      # Not thread-save method, should be called in synchronized code
+      # We need to return a new PageViewVisit for case if PageView was already sent and it's new visit
       def overwrite(page_view)
         @page_view = page_view
         @count += 1
       end
+
+      # Not thread-save method, should be called in synchronized code
+      def merge (page_view_visit)
+        @count += page_view_visit.count
+        @last_timestamp = [@last_timestamp, page_view_visit.last_timestamp].max
+      end
+
+      # Not thread-save method, should be called in synchronized code
+      def increase_page_visits
+        @count += 1
+      end
     end
   end
 end

data/lib/kameleoon/data/manager/visitor.rb

@@ -18,8 +18,9 @@ module Kameleoon
     # Visitor is a container of all data assigned to a visitor.
     # It is thread-safe
     class Visitor
-      attr_reader :last_activity_time, :user_agent, :device, :browser
-      attr_accessor :legal_consent
+      attr_reader :last_activity_time, :user_agent, :device, :browser, :geolocation, :operating_system, :cookie,
+                  :kcs_heat, :visitor_visits
+      attr_accessor :legal_consent, :mapping_identifier
 
       def initialize
         @mutex = Concurrent::ReadWriteLock.new
@@ -34,6 +35,8 @@ module Kameleoon
       def enumerate_sendable_data(&blk)
         blk.call(@device) unless @device.nil?
         blk.call(@browser) unless @browser.nil?
+        blk.call(@operating_system) unless @operating_system.nil?
+        blk.call(@geolocation) unless @geolocation.nil?
         @mutex.with_read_lock do
           @custom_data_map&.each { |_, cd| blk.call(cd) }
           @page_view_visits&.each { |_, pvv| blk.call(pvv.page_view) }
@@ -47,6 +50,8 @@ module Kameleoon
         @mutex.with_read_lock do
           count += 1 unless @device.nil?
           count += 1 unless @browser.nil?
+          count += 1 unless @geolocation.nil?
+          count += 1 unless @operating_system.nil?
           count += @custom_data_map.size unless @custom_data_map.nil?
           count += @page_view_visits.size unless @page_view_visits.nil?
           count += @conversions.size unless @conversions.nil?
@@ -71,22 +76,36 @@ module Kameleoon
         DataMapStorage.new(@mutex, @variations)
       end
 
-      def add_data(log_func, *args)
+      def add_data(log_func, *args, overwrite: true)
         @mutex.with_write_lock do
           args.each do |data|
             case data
             when Kameleoon::UserAgent
-              add_user_agent(data)
+              set_user_agent(data)
+            when Kameleoon::DataManager::AssignedVariation
+              add_variation(data, overwrite)
             when Kameleoon::Device
-              add_device(data)
+              set_device(data, overwrite)
             when Kameleoon::Browser
-              add_browser(data)
+              set_browser(data, overwrite)
             when Kameleoon::CustomData
-              add_custom_data(data)
+              add_custom_data(data, overwrite)
             when Kameleoon::PageView
               add_page_view(data)
+            when Kameleoon::DataManager::PageViewVisit
+              add_page_view_visit(data)
             when Kameleoon::Conversion
               add_conversion(data)
+            when Kameleoon::Cookie
+              set_cookie(data)
+            when Kameleoon::OperatingSystem
+              set_operating_system(data, overwrite)
+            when Kameleoon::Geolocation
+              set_geolocation(data, overwrite)
+            when Kameleoon::KcsHeat
+              set_kcs_heat(data)
+            when Kameleoon::VisitorVisits
+              set_visitor_visits(data)
             else
               log_func&.call("Data has unsupported type '#{data.class}'")
             end
@@ -103,21 +122,28 @@ module Kameleoon
 
       private
 
-      def add_user_agent(user_agent)
+      def set_user_agent(user_agent)
         @user_agent = user_agent.value
       end
 
-      def add_device(device)
-        @device = device
+      def set_device(device, overwrite)
+        @device = device if overwrite || @device == nil
       end
 
-      def add_browser(browser)
-        @browser = browser
+      def add_variation(variation, overwrite)
+        @variations = {} if @variations == nil
+        if overwrite || !@variations.include?(variation.experiment_id)
+          @variations[variation.experiment_id] = variation
+        end
       end
 
-      def add_custom_data(custom_data)
+      def set_browser(browser, overwrite)
+        @browser = browser if overwrite || @browser == nil
+      end
+
+      def add_custom_data(custom_data, overwrite)
         @custom_data_map = {} if @custom_data_map.nil?
-        @custom_data_map[custom_data.id] = custom_data
+        @custom_data_map[custom_data.id] = custom_data if overwrite || !@custom_data_map.include?(custom_data.id)
       end
 
       def add_page_view(page_view)
@@ -133,10 +159,41 @@ module Kameleoon
         @page_view_visits[page_view.url] = visit
       end
 
+      def add_page_view_visit(page_view_visit)
+        @page_view_visits = {} if @page_view_visits.nil?
+        visit = @page_view_visits[page_view_visit.page_view.url]
+        if visit.nil?
+          visit = page_view_visit
+          @page_view_visits[page_view_visit.page_view.url] = visit
+        else
+          visit.merge(page_view_visit)
+        end
+      end
+
       def add_conversion(conversion)
         @conversions = [] if @conversions.nil?
         @conversions.push(conversion)
       end
+
+      def set_geolocation(geolocation, overwrite)
+        @geolocation = geolocation if overwrite || @geolocation == nil
+      end
+
+      def set_cookie(cookie)
+        @cookie = cookie
+      end
+
+      def set_operating_system(operating_system, overwrite)
+        @operating_system = operating_system if overwrite || @operating_system == nil
+      end
+
+      def set_kcs_heat(kcs_heat)
+        @kcs_heat = kcs_heat
+      end
+
+      def set_visitor_visits(visitor_visits)
+        @visitor_visits = visitor_visits
+      end
     end
   end
 end

data/lib/kameleoon/data/manager/visitor_manager.rb

@@ -11,10 +11,12 @@ module Kameleoon
     # It is thread-safe except `stop` method
     class VisitorManager
       attr_reader :expiration_period
+      attr_accessor :custom_data_info
 
-      def initialize(expiration_period)
+      def initialize(expiration_period, log_func = nil)
         @expiration_period = expiration_period
         @visitors = Concurrent::Map.new
+        @log_func = log_func
         start
       end
 
@@ -49,6 +51,26 @@ module Kameleoon
         @visitors.size
       end
 
+      def add_data(visitor_code, *args)
+        visitor = get_or_create_visitor(visitor_code)
+        for custom_data in args
+          next unless custom_data.is_a?(Kameleoon::CustomData)
+          # We shouldn't send custom data with local only type
+          custom_data.mark_as_sent if @custom_data_info.local_only?(custom_data.id)
+          # If mappingIdentifier is passed, we should link anonymous visitor with real unique userId.
+          # After authorization, customer must be able to continue work with userId, but hash for variation
+          # should be calculated based on anonymous visitor code, that's why set MappingIdentifier to visitor.
+          if @custom_data_info.mapping_identifier?(custom_data.id) && custom_data.values.size > 0 && custom_data.values[0].size > 0
+            custom_data.is_mapping_identifier = true
+            visitor.mapping_identifier = visitor_code
+            target_visitor_code = custom_data.values[0]
+            @visitors[target_visitor_code] = visitor if visitor_code != target_visitor_code
+          end
+        end
+        visitor.add_data(@log_func, *args)
+        visitor
+      end
+
       private
 
       def purge

data/lib/kameleoon/data/operating_system.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module OperatingSystemType
+    WINDOWS = 0
+    MAC = 1
+    IOS = 2
+    LINUX = 3
+    ANDROID = 4
+    WINDOWS_PHONE = 5
+
+    def self.from_name(name)
+      case name
+      when 'WINDOWS'
+        WINDOWS
+      when 'MAC'
+        MAC
+      when 'IOS'
+        IOS
+      when 'LINUX'
+        LINUX
+      when 'ANDROID'
+        ANDROID
+      when 'WINDOWS_PHONE'
+        WINDOWS_PHONE
+      else
+        nil
+      end
+    end
+
+    def self.name_from_type(operating_system_type)
+      case operating_system_type
+      when OperatingSystemType::WINDOWS
+        'WINDOWS'
+      when OperatingSystemType::MAC
+        'MAC'
+      when OperatingSystemType::IOS
+        'IOS'
+      when OperatingSystemType::LINUX
+        'LINUX'
+      when OperatingSystemType::ANDROID
+        'ANDROID'
+      when OperatingSystemType::WINDOWS_PHONE
+        'WINDOWS_PHONE'
+      else
+        nil
+      end
+    end
+  end
+
+  # OperatingSystem contains information about the operating system on the visitor's device
+  class OperatingSystem < DuplicationUnsafeData
+    attr_reader :os_type
+
+    # @param [OperatingSystemType] os_type Operating system type, can be: WINDOWS, MAC, IOS, LINUX, ANDROID, WINDOWS_PHONE
+    def initialize(os_type)
+      super(DataType::OPERATING_SYSTEM)
+      @os_type = os_type
+    end
+
+    def obtain_full_post_text_line
+      params = {
+        eventType: 'staticData',
+        os: OperatingSystemType.name_from_type(@os_type),
+        osIndex: @os_type,
+        nonce: nonce
+      }
+      Kameleoon::Network::UriHelper.encode_query(params)
+    end
+  end
+end
+

data/lib/kameleoon/data/page_view.rb

@@ -10,9 +10,9 @@ module Kameleoon
     attr_reader :url, :title, :referrer
 
     # @param [String] url Url of the page
-    # @param [String] title Title of the page
+    # @param [String] title Optional field - title of the page
     # @param [Array] referrers Optional field - Referrer ids
-    def initialize(url, title, referrers = nil)
+    def initialize(url, title = nil, referrers = nil)
       super(DataType::PAGE_VIEW)
       @url = url || ''
       print('Kameleoon SDK: Url for PageView is required parameter, the data will be ignored.') if url == ''

data/lib/kameleoon/data/visitor_visits.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  class VisitorVisits
+    attr_reader :previous_visit_timestamps
+
+    def initialize(previous_visit_timestamps = [])
+      @previous_visit_timestamps = previous_visit_timestamps
+      @previous_visit_timestamps.freeze
+    end
+
+    def self.get_previous_visit_timestamps(visitor_visits)
+      visitor_visits.is_a?(VisitorVisits) ? visitor_visits.previous_visit_timestamps : []
+    end
+
+    def self.visitor_visits?(obj)
+      obj.nil? || obj.is_a?(VisitorVisits)
+    end
+  end
+end