kameleoon-client-ruby 2.3.0 → 3.1.0

data/lib/kameleoon/network/request.rb

@@ -5,16 +5,21 @@ module Kameleoon
     ##
     # Request represents HTTP request.
     class Request
-      attr_reader :method, :url, :content_type, :timeout, :user_agent, :data
+      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data, :access_token
 
-      def initialize(method, url, content_type, timeout, user_agent = nil, data = nil)
+      def initialize(method, url, content_type, timeout, user_agent: nil, extra_headers: nil, data: nil)
         @method = method
         @url = url
         @content_type = content_type
         @timeout = timeout
         @user_agent = user_agent
+        @extra_headers = extra_headers
         @data = !data.nil? && data.is_a?(String) ? data.encode('UTF-8') : data
       end
+
+      def authorize(access_token)
+        @access_token = access_token
+      end
     end
   end
 end

data/lib/kameleoon/network/response.rb

@@ -18,13 +18,5 @@ module Kameleoon
         @error.nil? && (@code / 100 == 2)
       end
     end
-
-    class DeferrableResponse < EventMachine::DefaultDeferrable
-      attr_writer :response
-
-      def callback(&blk)
-        blk.call(@response)
-      end
-    end
   end
 end

data/lib/kameleoon/network/url_provider.rb

@@ -12,17 +12,29 @@ module Kameleoon
       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'
+      ACCESS_TOKEN_PATH = '/oauth/token'
 
-      DEFAULT_DATA_API_URL = 'https://data.kameleoon.io'
-      TEST_DATA_API_URL = 'https://data.kameleoon.net'
+      CONFIGURATION_API_URL_FORMAT = 'https://sdk-config.kameleoon.eu/%s'
+      RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
+      DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
+      TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
+      DEFAULT_AUTOMATION_API_DOMAIN = 'api.kameleoon.com'
+      TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
 
-      attr_reader :site_code, :data_api_url
+      attr_reader :site_code, :data_api_domain, :automation_api_domain
 
-      def initialize(site_code, data_api_url)
+      def initialize(
+        site_code,
+        data_api_domain = DEFAULT_DATA_API_DOMAIN,
+        automation_api_domain = DEFAULT_AUTOMATION_API_DOMAIN
+      )
         @site_code = site_code
-        @data_api_url = data_api_url
+        @data_api_domain = data_api_domain
+        @automation_api_domain = automation_api_domain
+      end
+
+      def apply_data_api_domain(domain)
+        @data_api_domain = domain if domain.is_a?(String)
       end
 
       def make_tracking_url(visitor_code)
@@ -32,7 +44,7 @@ module Kameleoon
           siteCode: @site_code,
           visitorCode: visitor_code
         }
-        "#{@data_api_url}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_visitor_data_get_url(visitor_code)
@@ -44,7 +56,7 @@ module Kameleoon
           customData: true,
           version: 0
         }
-        "#{@data_api_url}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_api_data_get_request_url(key)
@@ -52,20 +64,26 @@ module Kameleoon
           siteCode: @site_code,
           key: key
         }
-        "#{@data_api_url}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_configuration_url(environment = nil, timestamp = nil)
-        params = { siteCode: @site_code }
+        url = format(CONFIGURATION_API_URL_FORMAT, @site_code)
+        params = {}
         params[:environment] = environment unless environment.nil?
         params[:ts] = timestamp unless timestamp.nil?
-        "#{CONFIGURATION_API_URL}?#{UriHelper.encode_query(params)}"
+        url = "#{url}?#{UriHelper.encode_query(params)}" unless params.empty?
+        url
       end
 
       def make_real_time_url
         params = { siteCode: @site_code }
         "#{RT_CONFIGURATION_URL}?#{UriHelper.encode_query(params)}"
       end
+
+      def make_access_token_url
+        "https://#{@automation_api_domain}#{ACCESS_TOKEN_PATH}"
+      end
     end
   end
 end

data/lib/kameleoon/real_time/sse_client.rb

@@ -2,6 +2,8 @@
 
 require 'kameleoon/real_time/sse_message'
 
+# TODO: Fix hanging (https://project.kameleoon.net/issues/26520)
+
 module Kameleoon
   module RealTime
     ##

data/lib/kameleoon/targeting/conditions/browser_condition.rb

@@ -22,9 +22,8 @@ module Kameleoon
         @version_match_type = json_condition['versionMatchType']
       end
 
-      def check(list_data)
-        browser = get_last_targeting_data(list_data, Kameleoon::DataType::BROWSER)
-        browser && check_targeting(browser)
+      def check(browser)
+        browser.is_a?(Kameleoon::Browser) && check_targeting(browser)
       end
 
       private

data/lib/kameleoon/targeting/conditions/conversion_condition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/conversion'
+require 'kameleoon/data/manager/data_array_storage'
 
 module Kameleoon
   # @api private
@@ -12,9 +13,16 @@ module Kameleoon
         @goal_id = json_condition['goalId']
       end
 
-      def check(list_data)
-        conversion = get_last_targeting_data(list_data, Kameleoon::DataType::CONVERSION)
-        conversion && (@goal_id.nil? || @goal_id == conversion.goal_id)
+      def check(conversion_storage)
+        return false unless conversion_storage.is_a?(Kameleoon::DataManager::DataArrayStorage)
+        return true if @goal_id.nil?
+
+        is_targeted = false
+        conversion_storage.enumerate do |conversion|
+          is_targeted = conversion.is_a?(Kameleoon::Conversion) && (@goal_id == conversion.goal_id)
+          break if is_targeted
+        end
+        is_targeted
       end
     end
   end

data/lib/kameleoon/targeting/conditions/custom_datum.rb

@@ -12,6 +12,10 @@ module Kameleoon
       include Kameleoon::Exception
 
       class << self
+        def op_undefined(values, value)
+          false
+        end
+
         def op_match(values, value)
           re = Regexp.new(value.to_s)
           values.any? { |v| re.match(v) }
@@ -26,7 +30,8 @@ module Kameleoon
         end
 
         def op_equal(values, value)
-          values.any? { |v| v.to_f == value.to_f }
+          epsilon = 1e-9
+          values.any? { |v| (v.to_f - value.to_f).abs < epsilon }
         end
 
         def op_greater(values, value)
@@ -52,6 +57,7 @@ module Kameleoon
       end
 
       @@op = {
+        Operator::UNDEFINED => method(:op_undefined),
         Operator::REGULAR_EXPRESSION => method(:op_match),
         Operator::CONTAINS => method(:op_contains),
         Operator::EXACT => method(:op_exact),
@@ -71,24 +77,24 @@ module Kameleoon
         end
 
         @type = ConditionType::CUSTOM_DATUM
-        @index = json_condition['customDataIndex']
+        @index = json_condition['customDataIndex'].to_i
         @operator = json_condition['valueMatchType']
+        @operation = @@op[@operator]
         @value = json_condition['value']
       end
 
-      def check(list_data)
-        is_targeted = false
-        custom_data = list_data.select { |data| data.instance == DataType::CUSTOM && data.id == @index }.last
-        if custom_data.nil?
-          is_targeted = (@operator == Operator::UNDEFINED.to_s)
-        elsif @operator != Operator::UNDEFINED.to_s
-          @operation = @@op[@operator]
-          unless @operation
-            raise KameleoonError.new("Undefined operator #{@operator}"), "Undefined operator #{@operator}"
+      def check(custom_data_storage)
+        is_targeted = nil
+        if custom_data_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+          custom_data = custom_data_storage.get(@index)
+          if custom_data.is_a?(Kameleoon::CustomData)
+            unless @operation
+              raise KameleoonError.new("Undefined operator #{@operator}"), "Undefined operator #{@operator}"
+            end
+            is_targeted = @operation.call(custom_data.values, @value)
           end
-
-          is_targeted = @operation.call(custom_data.values, @value)
         end
+        is_targeted = (@operator == Operator::UNDEFINED.to_s) if is_targeted.nil?
         is_targeted
       end
     end

data/lib/kameleoon/targeting/conditions/device_condition.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/device'
 
 module Kameleoon
   # @api private
@@ -12,9 +12,8 @@ module Kameleoon
         @device_type = json_condition['device']
       end
 
-      def check(list_data)
-        device = get_last_targeting_data(list_data, Kameleoon::DataType::DEVICE)
-        device && @device_type == device.device_type
+      def check(device)
+        device.is_a?(Kameleoon::Device) && @device_type == device.device_type
       end
     end
   end

data/lib/kameleoon/targeting/conditions/exclusive_experiment.rb

@@ -10,7 +10,8 @@ module Kameleoon
       def check(data)
         experiment_id = data.experiment_id
         storage = data.storage
-        storage.nil? || storage.empty? || (storage.length == 1 && !storage[experiment_id].nil?)
+        storage.is_a?(Kameleoon::DataManager::DataMapStorage) &&
+          (storage.size.zero? || ((storage.size == 1) && !storage.get(experiment_id).nil?))
       end
     end
   end

data/lib/kameleoon/targeting/conditions/page_title_condition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/manager/data_map_storage'
+require 'kameleoon/data/manager/page_view_visit'
 require_relative 'string_value_condition'
 
 module Kameleoon
@@ -12,9 +13,15 @@ module Kameleoon
         super(json_condition, json_condition['title'])
       end
 
-      def check(list_data)
-        page_view = get_last_targeting_data(list_data, Kameleoon::DataType::PAGE_VIEW)
-        page_view && check_targeting(page_view.title)
+      def check(page_view_visit_storage)
+        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+
+        is_targeted = false
+        page_view_visit_storage.enumerate do |visit|
+          is_targeted = visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.title)
+          break if is_targeted
+        end
+        is_targeted
       end
     end
   end

data/lib/kameleoon/targeting/conditions/page_url_condition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/manager/data_map_storage'
+require 'kameleoon/data/manager/page_view_visit'
 require_relative 'string_value_condition'
 
 module Kameleoon
@@ -12,9 +13,22 @@ module Kameleoon
         super(json_condition, json_condition['url'])
       end
 
-      def check(list_data)
-        page_view = get_last_targeting_data(list_data, Kameleoon::DataType::PAGE_VIEW)
-        page_view && check_targeting(page_view.url)
+      def check(page_view_visit_storage)
+        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+        return !page_view_visit_storage.get(condition_value).nil? if operator == Operator::EXACT
+
+        is_targeted = false
+        page_view_visit_storage.enumerate do |visit|
+          is_targeted = check_page_view_visit(visit)
+          break if is_targeted
+        end
+        is_targeted
+      end
+
+      private
+
+      def check_page_view_visit(visit)
+        visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.url)
       end
     end
   end

data/lib/kameleoon/targeting/conditions/string_value_condition.rb

@@ -19,6 +19,8 @@ module Kameleoon
 
       protected
 
+      attr_reader :operator, :condition_value
+
       def check_targeting(value)
         return false if value.nil?
 

data/lib/kameleoon/targeting/conditions/target_experiment.rb

@@ -24,16 +24,21 @@ module Kameleoon
       end
 
       def check(variation_storage)
-        is_targeted = false
-        variation_storage_exist = !variation_storage.nil? && !variation_storage.empty?
-        saved_variation = variation_storage[@experiment] unless variation_storage.nil?
+        return false unless variation_storage.is_a?(Kameleoon::DataManager::DataMapStorage) &&
+                            variation_storage.size.positive?
+
+        variation = variation_storage.get(@experiment)
+        return false unless variation.is_a?(Kameleoon::DataManager::AssignedVariation)
+
         case @operator
         when Operator::EXACT
-          is_targeted = variation_storage_exist && saved_variation == @variation
+          variation = variation_storage.get(@experiment)
+          variation.variation_id == @variation
         when Operator::ANY
-          is_targeted = variation_storage_exist
+          true
+        else
+          false
         end
-        is_targeted
       end
     end
   end

data/lib/kameleoon/utils.rb

@@ -1,16 +1,53 @@
 # frozen_string_literal: true
 
+require 'fiber'
+require 'bigdecimal'
+require 'kameleoon/utils'
+require 'kameleoon/exceptions'
+
 module Kameleoon
   # Utils is a helper module for project
   module Utils
     ALPHA_NUMERIC_CHARS = 'ABCDEF0123456789'
 
-    def self.in_seconds(days)
-      days * 60 * 60 * 24
-    end
-
     def self.generate_random_string(length)
       (1..length).map { ALPHA_NUMERIC_CHARS[rand(ALPHA_NUMERIC_CHARS.length)] }.join
     end
+
+    module VisitorCode
+      VISITOR_CODE_MAX_LENGTH = 255
+      VISITOR_CODE_LENGTH = 16
+
+      def self.validate(visitor_code)
+        raise Kameleoon::Exception::VisitorCodeInvalid, 'Empty visitor Code' if visitor_code&.empty?
+        if visitor_code.size > VISITOR_CODE_MAX_LENGTH
+          raise Kameleoon::Exception::VisitorCodeInvalid, "Visitor Code is longer than #{VISITOR_CODE_MAX_LENGTH} chars"
+        end
+      end
+
+      def self.generate
+        Utils.generate_random_string(VISITOR_CODE_LENGTH)
+      end
+    end
+
+    module HashDouble
+      def self.obtain(visitor_code, respool_times = {}, container_id = '')
+        obtain_helper(visitor_code, respool_times, container_id, '')
+      end
+
+      def self.obtain_rule(visitor_code, container_id = '', suffix = '')
+        obtain_helper(visitor_code, {}, container_id, suffix)
+      end
+
+      private
+
+      def self.obtain_helper(visitor_code, respool_times, container_id, suffix)
+        identifier = visitor_code.to_s
+        identifier += container_id.to_s
+        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
+    end
   end
 end

data/lib/kameleoon/version.rb

@@ -2,7 +2,7 @@
 
 module Kameleoon
   SDK_NAME = 'RUBY'
-  SDK_VERSION = '2.3.0'
+  SDK_VERSION = '3.1.0'
 
   # SdkManager is a helper method for fetching / obtaining version of SDK from string
   class SdkVersion

data/lib/kameleoon.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #
 # Kameleoon Ruby Client SDK
 #
-require "kameleoon/factory"
-require "kameleoon/client"
+require 'kameleoon/kameleoon_client_factory'
+require 'kameleoon/kameleoon_client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2024-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -75,29 +75,37 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/kameleoon.rb
-- lib/kameleoon/client.rb
-- lib/kameleoon/client_config.rb
-- lib/kameleoon/configuration/experiment.rb
+- lib/kameleoon/client_readiness.rb
+- lib/kameleoon/configuration/data_file.rb
 - lib/kameleoon/configuration/feature_flag.rb
 - lib/kameleoon/configuration/rule.rb
 - lib/kameleoon/configuration/settings.rb
 - lib/kameleoon/configuration/variable.rb
 - lib/kameleoon/configuration/variation.rb
 - lib/kameleoon/configuration/variation_exposition.rb
-- lib/kameleoon/cookie.rb
 - lib/kameleoon/data/browser.rb
 - lib/kameleoon/data/conversion.rb
 - lib/kameleoon/data/custom_data.rb
 - lib/kameleoon/data/data.rb
 - lib/kameleoon/data/device.rb
+- lib/kameleoon/data/manager/assigned_variation.rb
+- lib/kameleoon/data/manager/data_array_storage.rb
+- lib/kameleoon/data/manager/data_map_storage.rb
+- lib/kameleoon/data/manager/page_view_visit.rb
+- lib/kameleoon/data/manager/visitor.rb
+- lib/kameleoon/data/manager/visitor_manager.rb
 - lib/kameleoon/data/page_view.rb
 - lib/kameleoon/data/user_agent.rb
 - lib/kameleoon/exceptions.rb
-- lib/kameleoon/factory.rb
 - lib/kameleoon/hybrid/manager.rb
+- lib/kameleoon/kameleoon_client.rb
+- lib/kameleoon/kameleoon_client_config.rb
+- lib/kameleoon/kameleoon_client_factory.rb
+- lib/kameleoon/managers/warehouse/warehouse_manager.rb
+- lib/kameleoon/network/access_token_source.rb
 - lib/kameleoon/network/activity_event.rb
 - lib/kameleoon/network/content_type.rb
-- lib/kameleoon/network/experiment_event.rb
+- lib/kameleoon/network/cookie/cookie_manager.rb
 - lib/kameleoon/network/method.rb
 - lib/kameleoon/network/net_provider.rb
 - lib/kameleoon/network/network_manager.rb
@@ -112,8 +120,6 @@ files:
 - lib/kameleoon/real_time/sse_request.rb
 - lib/kameleoon/storage/cache.rb
 - lib/kameleoon/storage/cache_factory.rb
-- lib/kameleoon/storage/variation_storage.rb
-- lib/kameleoon/storage/visitor_variation.rb
 - lib/kameleoon/targeting/condition.rb
 - lib/kameleoon/targeting/condition_factory.rb
 - lib/kameleoon/targeting/conditions/browser_condition.rb

data/lib/kameleoon/client_config.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Kameleoon
-  # Client configuration which can be used instead of an external configuration file
-  class ClientConfig
-    CONFIGURATION_UPDATE_INTERVAL = 60
-    VISITOR_DATA_MAXIMUM_SIZE = 500
-    DEFAULT_TIMEOUT = 2000 # milli-seconds
-
-    attr_reader :client_id, :client_secret, :data_refresh_interval, :default_timeout, :configuration_refresh_interval,
-                :visitor_data_maximum_size, :environment, :verbose_mode
-
-    def initialize(
-      client_id: nil,
-      client_secret: nil,
-      configuration_refresh_interval: CONFIGURATION_UPDATE_INTERVAL,
-      default_timeout: DEFAULT_TIMEOUT,
-      visitor_data_maximum_size: VISITOR_DATA_MAXIMUM_SIZE,
-      environment: nil,
-      verbose_mode: false
-    )
-      @client_id = client_id
-      @client_secret = client_secret
-      @configuration_refresh_interval = configuration_refresh_interval || CONFIGURATION_UPDATE_INTERVAL
-      @default_timeout = default_timeout || DEFAULT_TIMEOUT
-      @visitor_data_maximum_size = visitor_data_maximum_size || VISITOR_DATA_MAXIMUM_SIZE
-      @environment = environment
-      @verbose_mode = verbose_mode || false
-    end
-
-    def self.make_from_yaml(yaml)
-      yaml ||= {}
-      ClientConfig.new(
-        client_id: yaml['client_id'],
-        client_secret: yaml['client_secret'],
-        configuration_refresh_interval: yaml['actions_configuration_refresh_interval'],
-        default_timeout: yaml['default_timeout'],
-        visitor_data_maximum_size: yaml['visitor_data_maximum_size'],
-        environment: yaml['environment'],
-        verbose_mode: yaml['verbose_mode']
-      )
-    end
-  end
-end

data/lib/kameleoon/configuration/experiment.rb

@@ -1,42 +0,0 @@
-# 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