kameleoon-client-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0d398647ef17fa8d33046f2f591973a57a00fde17fef994d955f23ea474538d
+  data.tar.gz: fc466cc6b762e1b4759dee2de2914c33ce27274b90bfe00394db5a80017f186e
+SHA512:
+  metadata.gz: ad96e42e9c7b75436dca8a6529d2118693b94be8edc7a6d7ee35bfa5cd0909235885f383a313b306912bb79a43aac6b8aee0c6e44d55135c79cca158113fba50
+  data.tar.gz: d2e75d812cf12088420984120337be790c7b3c60574181572d995f9ac613cf5b884820fddc4e7e2b4938ed3444f27d298e883f1560da34d83150d4b71207077a

data/README.md

@@ -0,0 +1,18 @@
+# Kameleoon RUBY SDK
+
+This is the repository for the Kameleoon Ruby SDK.
+
+### How to build and install Kameleoon Gem locally
+#### Prerequisite:
+* [Install ruby](https://www.ruby-lang.org/en/documentation/installation)
+
+#### Build and install:
+* Run `./buildAndInstallGem.sh`
+
+### How to run tests
+#### Prerequisite:
+* Build and install Kameleoon Gem locally (infos above).
+* Install rake: `gem install rake`
+
+#### Test:
+* Run `rake test`

data/lib/kameleoon.rb

@@ -0,0 +1,5 @@
+#
+# Kameleoon Ruby Client SDK
+#
+require "kameleoon/factory"
+require "kameleoon/client"

data/lib/kameleoon/client.rb

@@ -0,0 +1,503 @@
+require 'kameleoon/targeting/models'
+require 'kameleoon/request'
+require 'kameleoon/exceptions'
+require 'kameleoon/cookie'
+require 'rufus/scheduler'
+require 'yaml'
+require 'json'
+require 'em-synchrony'
+require 'objspace'
+
+module Kameleoon
+  ##
+  # Client for Kameleoon
+  #
+  class Client
+    include Request
+    include Cookie
+    include Exception
+
+    ##
+    # You should create Client with the Client Factory only.
+    def initialize(site_code, path_config_file, blocking, interval, default_timeout, client_id = nil, client_secret = nil)
+      config = YAML.load_file(path_config_file)
+      @site_code = site_code
+      @blocking = blocking
+      @default_timeout = config['default_timeout'] || default_timeout
+      @interval = config['actions_configuration_refresh_interval'] || interval
+      @tracking_url = config['tracking_url'] || "https://api-ssx.kameleoon.com"
+      @client_id = client_id || config['client_id']
+      @client_secret = client_secret || config['client_secret']
+      @data_maximum_size = config['visitor_data_maximum_size'] || 500
+      @experiments = []
+      @feature_flags = []
+      @data = {}
+    end
+
+    ##
+    # Obtain a visitor code.
+    #
+    #
+    # This method should be called to obtain the Kameleoon visitor_code for the current visitor.
+    # This is especially important when using Kameleoon in a mixed front-end and back-end environment,
+    # where user identification consistency must be guaranteed.
+    # @note The implementation logic is described here:
+    # First we check if a kameleoonVisitorCode cookie or query parameter associated with the current HTTP request can be
+    # found. If so, we will use this as the visitor identifier. If no cookie / parameter is found in the current
+    # request, we either randomly generate a new identifier, or use the defaultVisitorCode argument as identifier if it
+    # is passed. This allows our customers to use their own identifiers as visitor codes, should they wish to.
+    # This can have the added benefit of matching Kameleoon visitors with their own users without any additional
+    # look-ups in a matching table.
+    # In any case, the server-side (via HTTP header) kameleoonVisitorCode cookie is set with the value. Then this
+    # identifier value is finally returned by the method.
+    #
+    #
+    # @param [Hash] cookies Cookies of the request.
+    # @param [String] top_level_domain Top level domain of your website, settled while writing cookie.
+    # @param [String] default_visitor_vode - Optional - Define your default visitor_code (maximum length 100 chars).
+    #
+    # @return [String] visitor code
+    #
+    # @example
+    # cookies = {'kameleoonVisitorCode' => '1234asdf4321fdsa'}
+    # visitor_code = obtain_visitor_code(cookies, 'my-domaine.com')
+    #
+    def obtain_visitor_code(cookies, top_level_domain, default_visitor_code = nil)
+      read_and_write(cookies, top_level_domain, cookies, default_visitor_code)
+    end
+
+    ##
+    # Trigger an experiment.
+    # If such a visitor_code has never been associated with any variation, the SDK returns a randomly selected variation.
+    # If a user with a given visitor_code is already registered with a variation, it will detect the previously
+    # registered variation and return the variation_id.
+    # You have to make sure that proper error handling is set up in your code as shown in the example to the right to
+    # catch potential exceptions.
+    #
+    # @param [String] visitor_code Visitor code
+    # @param [Integer] experiment_id Id of the experiment you want to trigger.
+    #
+    # @return [Integer] Variation id
+    #
+    # @raise [Kameleoon::Exception::ExperimentNotFound] Raise when experiment configuration is not found
+    # @raise [Kameleoon::Exception::NotActivated] The visitor triggered the experiment, but did not activate it. Usually, this happens because the user has been associated with excluded traffic
+    # @raise [Kameleoon::Exception::NotTargeted] The visitor is not targeted by the experiment, as the associated targeting segment conditions were not fulfilled. He should see the reference variation
+    def trigger_experiment(visitor_code, experiment_id, timeout = @default_timeout)
+      experiment = @experiments.find { |experiment| experiment['id'].to_s == experiment_id.to_s }
+      if experiment.nil?
+        raise Exception::ExperimentNotFound.new(experiment_id)
+      end
+      if @blocking
+        variation_id = nil
+        EM.synchrony do
+          connexion_options = { :connect_timeout => timeout }
+          body = @data.values.flatten.select { |data| !data.sent }.map { |data| data.obtain_full_post_text_line }
+                      .join("\n") || ""
+          path = get_experiment_register_url(visitor_code, experiment_id)
+          request_options = { :path => path, :body => body }
+          request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
+          if is_successful(request)
+            variation_id = request.response
+          else
+            raise Exception::ExperimentNotFound.new(experiment_id) if variation_id.nil?
+          end
+          EM.stop
+        end
+        if variation_id.nil? || variation_id.to_s == "null" || variation_id.to_s == ""
+          raise Exception::NotTargeted.new(visitor_code)
+        elsif variation_id.to_s == "0"
+          raise Exception::NotActivated.new(visitor_code)
+        end
+        variation_id.to_i
+      else
+        visitor_data = @data.select { |key, value| key.to_s == visitor_code }.values.flatten! || []
+        if experiment['targetingSegment'].check_tree(visitor_data)
+          threshold = obtain_hash_double(visitor_code, experiment['respoolTime'], experiment['id'])
+          experiment['deviations'].each do |key, value|
+            threshold -= value
+            if threshold < 0
+              post_beacon("experimentTracking", visitor_code, experiment_id, key)
+              return key.to_s.to_i
+            end
+          end
+          post_beacon("experimentTracking", visitor_code, experiment_id, REFERENCE, true)
+          raise Exception::NotActivated.new(visitor_code)
+        end
+        raise Exception::NotTargeted.new(visitor_code)
+      end
+    end
+
+    ##
+    # Associate various data to a visitor. Note that this method doesn't return any value and doesn't interact with the
+    # Kameleoon back-end servers by itself. Instead, the declared data is saved for future sending via the flush method.
+    # This reduces the number of server calls made, as data is usually grouped into a single server call triggered by
+    # the execution of the flush method.
+    #
+    # @param [String] visitor_code Visitor code
+    # @param [...Data] data Data to associate with the visitor code
+    #
+    def add_data(visitor_code, *args)
+      while ObjectSpace.memsize_of(@data) > @data_maximum_size * (2**20) do
+        @data.shift
+      end
+      unless args.empty?
+        if @data.key?(visitor_code)
+          @data[visitor_code].push(*args)
+        else
+          @data[visitor_code] = args
+        end
+      end
+    end
+
+    ##
+    # Track conversions on a particular goal
+    # This method requires visitor_code and goal_id to track conversion on this particular goal.
+    # In addition, this method also accepts revenue as a third optional argument to track revenue. The visitor_code usually is identical to the one that was used when triggering the experiment.
+    # The track_conversion method doesn't return any value. This method is non-blocking as the server call is made asynchronously.
+    #
+    # @param [String] visitor_code Visitor code
+    # @param [Integer] goal_id Id of the goal
+    # @param [Float] revenue Revenue of the conversion. This field is optional
+    #
+    def track_conversion(visitor_code, goal_id, revenue = 0.0)
+      add_data(visitor_code, Conversion.new(goal_id, revenue))
+      flush(visitor_code)
+    end
+
+    ##
+    # Flush the associated data.
+    # The data added with the method add_data, is not directly sent to the kameleoon servers.
+    # It's stored and accumulated until it is sent automatically by the trigger_experiment or track_conversion methods.
+    # With this method you can manually send it.
+    #
+    # @param [String] visitor_code Optional field - Visitor code, without visitor code it flush all of the data
+    #
+    def flush(visitor_code = nil)
+      post_beacon("dataTracking", visitor_code)
+    end
+
+    ##
+    # Obtain variation associated data.
+    # To retrieve JSON data associated with a variation, call the obtain_variation_associated_data method of our SDK.
+    # The JSON data usually represents some metadata of the variation, and can be configured on our web application
+    # interface or via our Automation API.
+    # This method takes the variationID as a parameter and will return the data as a json string.
+    # It will throw an exception () if the variation ID is wrong or corresponds to an experiment that is not yet online.
+    #
+    # @param [Integer] variation_id
+    #
+    # @return [String] json string of the variation data.
+    #
+    # @raise [Kameleoon::Exception::VariationNotFound] Raise exception if the variation is not found.
+    def obtain_variation_associated_data(variation_id)
+      variation = @experiments.map { |experiment| experiment['variations'] }.flatten.select { |variation| variation['id'].to_i == variation_id.to_i }.first
+      if variation.nil?
+        raise Exception::VariationNotFound.new(variation_id)
+      else
+        variation['customJson'].to_json
+      end
+    end
+
+    #
+    # Method to activate a feature toggle.
+    #
+    # This method takes a visitor_code and feature_key (or feature_id) as mandatory arguments to check if the specified feature will be active for a given user.
+    # If such a user has never been associated with this feature flag, the SDK returns a boolean value randomly (true if the user should have this feature or false if not). If a user with a given visitorCode is already registered with this feature flag, it will detect the previous featureFlag value.
+    # You have to make sure that proper error handling is set up in your code as shown in the example to the right to catch potential exceptions.
+    #
+    # @param [String] visitor_code
+    # @param [String | Integer] feature_key
+    #
+    # @raise [Kameleoon::Exception::FeatureFlagNotFound]
+    # @raise [Kameleoon::Exception::NotTargeted]
+    def activate_feature(visitor_code, feature_key, timeout = @default_timeout)
+      feature_flag = get_feature_flag(feature_key)
+      id = feature_flag['id']
+      if @blocking
+        result = nil
+        EM.synchrony do
+          connexion_options = { :connect_timeout => timeout }
+          request_options = {
+            :path => get_experiment_register_url(visitor_code, id),
+            :body => (select_data_to_sent(visitor_code).values.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
+          }
+          request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
+          if is_successful(request)
+            result = request.response
+          end
+          EM.stop
+        end
+        raise Exception::FeatureFlagNotFound.new(id) if result.nil?
+        result.to_s != "null"
+
+      else
+        visitor_data = @data.select { |key, value| key.to_s == visitor_code }.values.flatten! || []
+        if feature_flag['targetingSegment'].nil? || feature_flag['targetingSegment'].check_tree(visitor_data)
+          threshold = obtain_hash_double(visitor_code, {}, id)
+          if threshold <= feature_flag['expositionRate']
+            post_beacon("experimentTracking", visitor_code, id, feature_flag["variationsId"].first)
+            return true
+          else
+            post_beacon("experimentTracking", visitor_code, id, REFERENCE, true)
+            return false
+          end
+        else
+          raise Exception::NotTargeted.new(visitor_code)
+        end
+      end
+    end
+
+    ##
+    #  Method To retrieve a feature variable. A feature variable can be changed easily via our web application.
+    #
+    # @param [String | Integer] feature_key
+    # @param [String ] variable_key
+    #
+    # @raise [Kameleoon::Exception::FeatureFlagNotFound]
+    def obtain_feature_variable(feature_key, variable_key)
+      feature_flag = get_feature_flag(feature_key)
+      custom_json = feature_flag["variations"].first['customJson'][variable_key.to_s]
+      if custom_json.nil?
+        raise Exception::FeatureFlagNotFound.new("Feature variable not found")
+      end
+      case custom_json['type']
+      when "Boolean"
+        return !!custom_json['value']
+      when "String"
+        return custom_json['value'].to_s
+      when "Number"
+        return custom_json['value'].to_f
+      when "Json"
+        return custom_json['value'].to_json
+      else
+        raise Exception::FeatureFlagNotFound.new("Unknown type for feature variable")
+      end
+    end
+
+    private
+    API_SSX_URL = "https://api-ssx.kameleoon.com"
+    REFERENCE = 0
+    attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :scheduler, :data,
+         :blocking, :tracking_url, :default_timeout, :interval, :memory_limit
+
+    def fetch_configuration
+      print "=> Starting Scheduler"
+      @scheduler = Rufus::Scheduler.singleton
+      @scheduler.every @interval do
+        fetch_configuration_job
+      end
+      @scheduler.schedule '0s' do
+        fetch_configuration_job
+      end
+    end
+
+    def fetch_configuration_job
+      EM.synchrony do
+        obtain_access_token
+        site = obtain_site
+        if site.nil? || site.empty?
+          @experiments ||= []
+          @feature_flags ||= []
+        else
+          site_id = site.first['id']
+          @experiments = obtain_tests(site_id)
+          @feature_flags = obtain_feature_flags(site_id)
+        end
+        EM.stop
+      end
+    end
+
+    def hash_headers
+      if @access_token.nil?
+        CredentialsNotFound.new
+      end
+      {
+        'Authorization' => 'Bearer ' + @access_token.to_s,
+        'Content-Type' => 'application/json'
+      }
+    end
+
+    def hash_filter(field, operator, parameters)
+      { 'field' => field, 'operator' => operator, 'parameters' => parameters }
+    end
+
+    def obtain_site
+      query_params = { 'perPage' => 1 }
+      filters = [hash_filter('code', 'EQUAL', [@site_code])]
+      request = fetch_one('sites', query_params, filters)
+      if request != false
+        JSON.parse(request.response)
+      end
+    end
+
+    def obtain_access_token
+      body = {
+        'grant_type' => 'client_credentials',
+        'client_id' => @client_id,
+        'client_secret' => @client_secret
+      }
+      header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+
+      request = EM::Synchrony.sync post({ :path => '/oauth/token', :body => body, :head => header })
+      if is_successful(request)
+        @access_token = JSON.parse(request.response)['access_token']
+      end
+    end
+
+    def obtain_variation(variation_id)
+      request = fetch_one('variations/' + variation_id.to_s)
+      if request != false
+        JSON.parse(request.response)
+      end
+    end
+
+    def obtain_segment(segment_id)
+      request = fetch_one('segments/' + segment_id.to_s)
+      if request != false
+        JSON.parse(request.response)
+      end
+    end
+
+    def complete_experiment(experiment)
+      unless experiment['variationsId'].nil?
+        experiment['variations'] = experiment['variationsId'].map { |variationId| obtain_variation(variationId) }
+      end
+      unless experiment['targetingSegmentId'].nil?
+        experiment['targetingSegment'] = Kameleoon::Targeting::Segment.new(obtain_segment(experiment['targetingSegmentId']))
+      end
+      experiment
+    end
+
+    def obtain_tests(site_id, per_page = -1)
+      query_values = { 'perPage' => per_page }
+      filters = [
+        hash_filter('siteId', 'EQUAL', [site_id]),
+        hash_filter('status', 'EQUAL', ['ACTIVE']),
+        hash_filter('type', 'IN', ['SERVER_SIDE', 'HYBRID'])
+      ]
+      fetch_all('experiments', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |test|
+        complete_experiment(test)
+      end
+    end
+
+    def obtain_feature_flags(site_id, per_page = -1)
+      query_values = { 'perPage' => per_page }
+      filters = [
+        hash_filter('siteId', 'EQUAL', [site_id]),
+        hash_filter('status', 'EQUAL', ['ACTIVE'])
+      ]
+      fetch_all('feature-flags', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |ff|
+        complete_experiment(ff)
+      end
+    end
+
+    def fetch_all(path, query_values = {}, filters = [])
+      results = []
+      current_page = 1
+      loop do
+        query_values['page'] = current_page
+        http = fetch_one(path, query_values, filters)
+        break if http == false
+        results.push(http)
+        break if http.response_header["X-Pagination-Page-Count"].to_i <= current_page
+        current_page += 1
+      end
+      results
+    end
+
+    def fetch_one(path, query_values = {}, filters = [])
+      unless filters.empty?
+        query_values['filter'] = filters.to_json
+      end
+      request = EM::Synchrony.sync get({ :path => path, :query => query_values, :head => hash_headers })
+      unless is_successful(request)
+        return false
+      end
+      request
+    end
+
+    def get_common_ssx_parameters(visitor_code)
+      {
+        :nonce => Kameleoon::Utils.generate_random_string(16),
+        :siteCode => @site_code,
+        :visitorCode => visitor_code
+      }
+    end
+
+    def get_experiment_register_url(visitor_code, experiment_id, variation_id = nil, none_variation = false)
+      url = "/experimentTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
+      url += "&experimentId=" + experiment_id.to_s
+      if variation_id.nil?
+        return url
+      end
+      url += "&variationId=" + variation_id.to_s
+      if none_variation
+        url += "&noneVariation=true"
+      end
+      url
+    end
+
+    def get_feature_flag(feature_key)
+      if feature_key.is_a?(String)
+        feature_flag = @feature_flags.select { |ff| ff['identificationKey'] == feature_key}.first
+      elsif feature_key.is_a?(Integer)
+        feature_flag = @feature_flags.select { |ff| ff['id'].to_i == feature_key}.first
+      else
+        raise TypeError.new("Feature key should be a String or an Integer.")
+      end
+      if feature_flag.nil?
+        raise Exception::FeatureFlagNotFound.new(feature_key)
+      end
+      feature_flag
+    end
+
+    def post_beacon(type = "dataTracking", visitor_code = nil, experiment_id = nil, variation_id = nil, none_variation = false)
+      Thread.new do
+        EM.synchrony do
+          entries = select_data_to_sent(visitor_code)
+          trials = 10
+          concurrency = 1
+          while !entries.empty? && trials > 0
+            EM::Synchrony::Iterator.new(entries, concurrency).map do |entry, iter|
+              options = {
+                :path => build_beacon_path(type, entry.first || visitor_code, experiment_id, variation_id, none_variation),
+                :body => (entry.last.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
+                :head => { "Content-Type" => "text/plain" }
+              }
+              request = post(options, @tracking_url)
+              request.callback {
+                if is_successful(request)
+                  entry.last.each { |data| data.sent = true }
+                end
+                iter.return(request)
+              }
+              request.errback { iter.return(request) }
+            end
+            entries = select_data_to_sent(visitor_code)
+            trials -= 1
+          end
+          EM.stop
+        end
+        Thread.exit
+      end
+    end
+
+    def select_data_to_sent(visitor_code)
+      if visitor_code.nil?
+        @data.select {|key, values| values.any? {|data| !data.sent}}
+      else
+        @data.select { |key, values| key == visitor_code && values.any? {|data| !data.sent} }
+      end
+    end
+
+    def build_beacon_path(type, visitor_code, experiment_id = nil, variation_id = nil, none_variation = nil)
+      if type == "dataTracking"
+        return "/dataTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
+      elsif type == "experimentTracking"
+        return get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation)
+      else
+        raise TypeError("Unknown type for post_beacon: " + type.to_s)
+      end
+    end
+  end
+end

data/lib/kameleoon/cookie.rb

@@ -0,0 +1,65 @@
+require 'fiber'
+require 'em-http'
+require 'eventmachine'
+require 'bigdecimal'
+require 'kameleoon/utils'
+
+module Kameleoon
+  # @api private
+  module Cookie
+    # @return [String] visitor code
+    def read_and_write(request_cookies, top_level_domain, response_cookies, default_visitor_code = nil)
+      kameleoon_visitor_code = read(request_cookies)
+      if kameleoon_visitor_code.nil?
+        kameleoon_visitor_code = check_default_visitor_code(default_visitor_code) || Kameleoon::Utils.generate_random_string(KAMELEOON_COOKIE_VALUE_LENGTH)
+      end
+      cookie = { :value => kameleoon_visitor_code, :expires => Time.now + Kameleoon::Utils.in_seconds(EXPIRE_DAYS), :path => '/' }
+      unless top_level_domain.nil?
+        cookie[:domain] = top_level_domain
+      end
+      response_cookies[KAMELEOON_COOKIE_NAME] = cookie
+      kameleoon_visitor_code
+    end
+
+    def obtain_hash_double(visitor_code, respool_times = {}, container_id = '')
+      identifier = visitor_code.to_s
+      identifier += container_id.to_s
+      if !respool_times.nil? && !respool_times.empty?
+        identifier += respool_times.values.sort.join.to_s
+      end
+      (Digest::SHA256.hexdigest(identifier.encode('UTF-8')).to_i(16) / (BigDecimal("2") ** BigDecimal("256"))).round(16)
+    end
+
+    private
+
+    KAMELEOON_KEY_JS_COOKIE = "_js_"
+    KAMELEOON_COOKIE_VALUE_LENGTH = 16
+    KAMELEOON_VISITOR_CODE_LENGTH = 100
+    KAMELEOON_COOKIE_NAME = 'kameleoonVisitorCode'
+    EXPIRE_DAYS = 380
+
+    def check_default_visitor_code(default_visitor_code)
+      if default_visitor_code.nil?
+        return nil
+      end
+      default_visitor_code[0..(KAMELEOON_VISITOR_CODE_LENGTH - 1)]
+    end
+
+    def read(cookies)
+      value = cookies[KAMELEOON_COOKIE_NAME]
+      if value.nil?
+        return
+      end
+      if value.start_with?(KAMELEOON_KEY_JS_COOKIE)
+        start_index = KAMELEOON_KEY_JS_COOKIE.length
+        value = value[start_index..-1]
+      end
+      if value.length < KAMELEOON_COOKIE_VALUE_LENGTH
+        return nil
+      end
+      value[0..(KAMELEOON_COOKIE_VALUE_LENGTH - 1)]
+    end
+  end
+end
+
+

data/lib/kameleoon/data.rb

@@ -0,0 +1,145 @@
+
+module Kameleoon
+  NONCE_LENGTH = 16
+
+  module DataType
+    CUSTOM = "CUSTOM"
+    BROWSER = "BROWSER"
+    CONVERSION = "CONVERSION"
+    INTEREST = "INTEREST"
+    PAGE_VIEW = "PAGE_VIEW"
+  end
+
+  module BrowserType
+    CHROME = 0
+    INTERNET_EXPLORER = 1
+    FIREFOX = 2
+    SAFARI = 3
+    OPERA = 4
+    OTHER = 5
+  end
+
+  class Data
+    attr_accessor :instance, :sent
+
+    def initialize(*args)
+      raise KameleoonError.new("Cannot initialise interface.")
+    end
+
+    def obtain_full_post_text_line
+      raise KameleoonError.new("ToDo: implement this method.")
+    end
+  end
+
+  class CustomData < Data
+    attr_accessor :id, :value
+
+    # @param [Integer] id Id of the custom data
+    # @param [String] value Value of the custom data
+    #
+    # @overload
+    # @param [Hash] hash Json value encoded in a hash.
+    def initialize(*args)
+      @instance = DataType::CUSTOM
+      @sent = false
+      unless args.empty?
+        if args.length == 1
+          hash = args.first
+          if hash["id"].nil?
+            raise NotFoundError.new("id")
+          end
+          @id = hash["id"].to_s
+          if hash["value"].nil?
+            raise NotFoundError.new(hash["value"])
+          end
+          @value = hash["value"]
+        elsif args.length == 2
+          @id = args[0].to_s
+          @value = args[1]
+        end
+      end
+    end
+
+    def obtain_full_post_text_line
+      to_encode = "[[\"" + @value.to_s.gsub("\"", "\\\"") + "\",1]]"
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=customData&index=" + @id.to_s + "&valueToCount=" + URI.encode_www_form_component(to_encode) + "&overwrite=true&nonce=" + nonce
+    end
+  end
+
+  class Browser < Data
+    attr_accessor :browser
+
+    # @param [BrowserType] browser_type Browser type, can be: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER
+    def initialize(browser_type)
+      @instance = DataType::BROWSER
+      @sent = false
+      @browser = browser_type
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=staticData&browser=" + @browser.to_s + "&nonce=" + nonce
+    end
+  end
+
+  class PageView < Data
+    attr_accessor :url, :title, :referrer
+
+    # @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)
+      @instance = DataType::PAGE_VIEW
+      @sent = false
+      @url = url
+      @title = title
+      @referrer = referrer
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      referrer_text = ""
+      unless @referrer.nil?
+        referrer_text = "&referrers=[" + @referrer + "]"
+      end
+      "eventType=page&href=" + @url + "&title=" + @title + "&keyPages=[]" + referrer_text + "&nonce=" + nonce
+    end
+  end
+
+  class Conversion < Data
+    attr_accessor :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)
+      @instance = DataType::CONVERSION
+      @sent = false
+      @goal_id = goal_id
+      @revenue = revenue
+      @negative = negative
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=conversion&goalId=" + @goal_id.to_s + "&revenue=" + @revenue.to_s + "&negative=" + @negative.to_s + "&nonce=" + nonce
+    end
+  end
+
+  class Interest < Data
+    attr_accessor :index
+
+    # @param [Integer] index Index of the interest
+    def initialize(index)
+      @instance = DataType::INTEREST
+      @sent = false
+      @index = index
+    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
+    end
+  end
+end

data/lib/kameleoon/exceptions.rb

@@ -0,0 +1,44 @@
+module Kameleoon
+  module Exception
+    class KameleoonError < ::StandardError
+      def initialize(message = nil)
+        super("Kameleoon error: " + message)
+      end
+    end
+    class NotFound < KameleoonError
+      def initialize(value = "")
+        super(value.to_s + " not found.")
+      end
+    end
+    class VariationNotFound < NotFound
+      def initialize(id = "")
+        super("Variation " + id.to_s)
+      end
+    end
+    class ExperimentNotFound < NotFound
+      def initialize(id = "")
+        super("Experiment " + id.to_s)
+      end
+    end
+    class FeatureFlagNotFound < NotFound
+      def initialize(id = "")
+        super("Feature flag " + id.to_s)
+      end
+    end
+    class CredentialsNotFound < NotFound
+      def initialize
+        super("Credentials")
+      end
+    end
+    class NotTargeted < KameleoonError
+      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.")
+      end
+    end
+  end
+end

data/lib/kameleoon/factory.rb

@@ -0,0 +1,24 @@
+require 'kameleoon/client'
+
+module Kameleoon
+  module ClientFactory
+    CONFIGURATION_UPDATE_INTERVAL= "60m"
+    CONFIG_PATH = "/etc/kameleoon/client-ruby.yaml"
+    DEFAULT_TIMEOUT = 2 #seconds
+
+    ##
+    # 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(:fetch_configuration)
+      client
+    end
+  end
+end

data/lib/kameleoon/request.rb

@@ -0,0 +1,43 @@
+require "em-synchrony/em-http"
+
+module Kameleoon
+  # @api private
+  module Request
+    protected
+    API_URL = "https://api.kameleoon.com"
+
+    module Method
+      GET = "get"
+      POST = "post"
+    end
+
+    def get(request_options, url = API_URL, connexion_options = {})
+      request(Method::GET, request_options, url, connexion_options)
+    end
+
+    def post(request_options, url = API_URL, connexion_options = {})
+      request(Method::POST, request_options, url, connexion_options)
+    end
+
+    private
+
+    def request(method, request_options, url, connexion_options)
+      request_options[:tls] = {verify_peer: true}
+      case method
+        when Method::POST then
+          return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
+        when Method::GET then
+          return EventMachine::HttpRequest.new(url, connexion_options).aget request_options
+        else
+          print "Unknown request type"
+          return false
+      end
+    end
+
+    def is_successful(request)
+      !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
+    end
+  end
+end
+
+

data/lib/kameleoon/targeting/condition.rb

@@ -0,0 +1,16 @@
+module Kameleoon
+  #@api private
+  module Targeting
+    class Condition
+      attr_accessor :type, :include
+
+      def initialize(json_conditions)
+        raise "Abstract class cannot be instantiate"
+      end
+
+      def check(conditions)
+        raise "Todo: Implement check method in condition"
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -0,0 +1,17 @@
+require 'kameleoon/targeting/models'
+require 'kameleoon/targeting/conditions/custom_datum'
+
+module Kameleoon
+  #@api private
+  module Targeting
+    module ConditionFactory
+      def get_condition(condition_json)
+        condition = nil
+        if condition_json['targetingType'] == ConditionType::CUSTOM_DATUM.to_s
+          condition = CustomDatum.new(condition_json)
+        end
+        condition
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'kameleoon/targeting/condition'
+require 'kameleoon/exceptions'
+require 'kameleoon/targeting/models'
+
+module Kameleoon
+  #@api private
+  module Targeting
+    class CustomDatum < Condition
+      include Kameleoon::Exception
+
+      attr_accessor :index, :operator, :value
+      def initialize(json_condition)
+        if json_condition['customDataIndex'].nil?
+          raise Exception::NotFoundError.new('customDataIndex')
+        end
+        @index = json_condition['customDataIndex']
+
+        if json_condition['valueMatchType'].nil?
+          raise Exception::NotFoundError.new('valueMatchType')
+        end
+        @operator = json_condition['valueMatchType']
+
+        if json_condition['value'].nil?
+          raise Exception::NotFoundError.new('value')
+        end
+        @value = json_condition['value']
+
+        @type = ConditionType::CUSTOM_DATUM
+
+        if json_condition['include'].nil?
+          raise Exception::NotFoundError.new('include')
+        end
+        @include = json_condition['include']
+      end
+
+      def check(datas)
+        is_targeted = false
+        custom_data = datas.select { |data| data.instance == DataType::CUSTOM && data.id == @index }.first
+        if custom_data.nil?
+          is_targeted = (@operator == Operator::UNDEFINED.to_s)
+        else
+          case @operator
+          when Operator::MATCH.to_s
+            if Regexp.new(@value.to_s).match(custom_data.value.to_s)
+              is_targeted = true
+            end
+          when Operator::CONTAINS.to_s
+            if custom_data.value.to_s.include? @value
+              is_targeted = true
+            end
+          when Operator::EXACT.to_s
+            if custom_data.value.to_s == @value.to_s
+              is_targeted = true
+            end
+          when Operator::EQUAL.to_s
+            if custom_data.value.to_f == @value.to_f
+              is_targeted = true
+            end
+          when Operator::GREATER.to_s
+            if custom_data.value.to_f > @value.to_f
+              is_targeted = true
+            end
+          when Operator::LOWER.to_s
+            if custom_data.value.to_f < @value.to_f
+              is_targeted = true
+            end
+          when Operator::IS_TRUE.to_s
+            if custom_data.value == true
+              is_targeted = true
+            end
+          when Operator::IS_FALSE.to_s
+            if custom_data.value == false
+              is_targeted = true
+            end
+          else
+            raise KameleoonError.new("Undefined operator " + @operator.to_s)
+          end
+        end
+        is_targeted
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/models.rb

@@ -0,0 +1,161 @@
+require 'kameleoon/targeting/tree_builder'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  #@api private
+  module Targeting
+    class Segment
+      include TreeBuilder
+      attr_accessor :id, :tree
+      def to_s
+        print("\nSegment id: " + @id.to_s)
+        print("\n")
+        @tree.to_s
+      end
+
+      def initialize(*args)
+        unless args.empty?
+          if args.length == 1
+            hash = args.first
+            if hash.nil?
+              raise Kameleoon::Exception::NotFound.new("arguments for segment")
+            end
+            if hash["id"].nil?
+              raise Kameleoon::Exception::NotFound.new("id")
+            end
+            @id = hash["id"]
+            if hash["conditionsData"].nil?
+              raise Kameleoon::Exception::NotFound.new(hash["conditionsData"])
+            end
+            @tree = create_tree(hash["conditionsData"])
+          elsif args.length == 2
+            @id = args[0]
+            @tree = args[1]
+          end
+        end
+      end
+
+      def check_tree(targeting_data)
+        if @tree.nil?
+          is_targeted = true
+        else
+          is_targeted = @tree.check(targeting_data)
+        end
+        is_targeted == true
+      end
+    end
+
+    class Tree
+      attr_accessor :or_operator, :left_child, :right_child, :condition
+
+      def to_s
+        print("or_operator: " + @or_operator.to_s)
+        print("\n")
+        print("condition: " + @condition.to_s)
+        unless @left_child.nil?
+          print("\n")
+          print("Left child:\n    ")
+          @left_child.to_s
+        end
+        unless @right_child.nil?
+          print("\n")
+          print("right child:\n    ")
+          @right_child.to_s
+        end
+      end
+
+      def initialize(or_operator = nil, left_child = nil, right_child = nil, condition = nil)
+        @or_operator = Marshal.load(Marshal.dump(or_operator))
+        @left_child = left_child
+        @right_child = right_child
+        @condition = condition
+      end
+
+      def check(datas)
+        unless @condition.nil?
+          is_targeted = check_condition(datas)
+        else
+          if @left_child.nil?
+            is_left_child_targeted = true
+          else
+            is_left_child_targeted = @left_child.check(datas)
+          end
+
+          if is_left_child_targeted.nil?
+            has_to_compute_right_child = true
+          else
+            has_to_compute_right_child = (is_left_child_targeted != @or_operator)
+          end
+
+          # Compute right child tree
+          is_right_child_targeted = nil
+          if has_to_compute_right_child
+            if @right_child.nil?
+              is_right_child_targeted = true
+            else
+              is_right_child_targeted = @right_child.check(datas)
+            end
+          end
+
+          # Computing results
+          if is_left_child_targeted.nil?
+            if is_right_child_targeted == @or_operator
+              is_targeted = Marshal.load(Marshal.dump(@or_operator)) #Deep copy
+            else
+              is_targeted = nil
+            end
+          else
+            if is_left_child_targeted == @or_operator
+              is_targeted = Marshal.load(Marshal.dump(@or_operator)) #Deep copy
+            else
+              if is_right_child_targeted == true
+                is_targeted = true
+              elsif is_right_child_targeted == false
+                is_targeted = false
+              else
+                is_targeted = nil
+              end
+            end
+          end
+        end
+        Marshal.load(Marshal.dump(is_targeted)) #Deep copy
+      end
+
+      def check_condition(datas, condition = @condition)
+        if condition.nil?
+          is_targeted = true
+        else
+          is_targeted = condition.check(datas)
+          unless condition.include
+            if is_targeted.nil?
+              is_targeted = true
+            else
+              is_targeted = !is_targeted
+            end
+          end
+        end
+        Marshal.load(Marshal.dump(is_targeted)) #Deep copy
+      end
+    end
+
+    module DataType
+      CUSTOM = "CUSTOM"
+    end
+
+    module ConditionType
+      CUSTOM_DATUM = "CUSTOM_DATUM"
+    end
+
+    module Operator
+      UNDEFINED = "UNDEFINED"
+      CONTAINS = "CONTAINS"
+      EXACT = "EXACT"
+      MATCH = "REGULAR_EXPRESSION"
+      LOWER = "LOWER"
+      EQUAL = "EQUAL"
+      GREATER = "GREATER"
+      IS_TRUE = "TRUE"
+      IS_FALSE = "FALSE"
+    end
+  end
+end

data/lib/kameleoon/targeting/tree_builder.rb

@@ -0,0 +1,73 @@
+require 'kameleoon/targeting/condition_factory'
+require 'kameleoon/targeting/models'
+
+module Kameleoon
+  #@api private
+  module Targeting
+    module TreeBuilder
+
+      def create_tree(conditions_data_json)
+        if conditions_data_json.nil?
+          return nil
+        end
+        if conditions_data_json['firstLevel'].empty?
+          conditions_data_json['firstLevelOrOperators'] = []
+        end
+        create_first_level(conditions_data_json)
+      end
+
+      private
+      include ConditionFactory
+
+      def create_first_level(conditions_data_json)
+        unless conditions_data_json['firstLevel'].empty?
+          left_first_level = conditions_data_json['firstLevel'].shift
+          left_child = create_second_level(left_first_level)
+
+          unless conditions_data_json['firstLevel'].empty?
+            or_operator = conditions_data_json['firstLevelOrOperators'].shift
+            if or_operator
+              return Tree.new(or_operator, left_child, create_first_level(conditions_data_json))
+            end
+
+            right_first_level = conditions_data_json['firstLevel'].shift
+            right_child = create_second_level(right_first_level)
+            tree = Tree.new(or_operator, left_child, right_child)
+
+            unless conditions_data_json['firstLevel'].empty?
+              return Tree.new(conditions_data_json['firstLevelOrOperators'].shift, tree, create_first_level(conditions_data_json))
+            end
+            return tree
+          end
+          return left_child
+        end
+        nil
+      end
+
+      def create_second_level(conditions_data_json)
+
+        unless conditions_data_json.nil? or conditions_data_json['conditions'].empty?
+          left_child = Tree.new
+          left_child.condition = get_condition(conditions_data_json['conditions'].shift)
+
+          unless conditions_data_json['conditions'].empty?
+            or_operator = conditions_data_json['orOperators'].shift
+            if or_operator
+              return Tree.new(or_operator, left_child, create_second_level(conditions_data_json))
+            end
+
+            right_child = Tree.new
+            right_child.condition = get_condition(conditions_data_json['conditions'].shift)
+            tree = Tree.new(or_operator, left_child, right_child)
+            unless conditions_data_json['conditions'].empty?
+              return Tree.new(conditions_data_json['orOperators'].shift, tree, create_second_level(conditions_data_json))
+            end
+            return tree
+          end
+          return left_child
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/kameleoon/utils.rb

@@ -0,0 +1,13 @@
+module Kameleoon
+  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
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: kameleoon-client-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kameleoon - Guillaume Grandjean
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: Kameleoon Client Ruby Software Development Kit
+email:
+- ggrandjean@kameleoon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/kameleoon.rb
+- lib/kameleoon/client.rb
+- lib/kameleoon/cookie.rb
+- lib/kameleoon/data.rb
+- lib/kameleoon/exceptions.rb
+- lib/kameleoon/factory.rb
+- lib/kameleoon/request.rb
+- lib/kameleoon/targeting/condition.rb
+- lib/kameleoon/targeting/condition_factory.rb
+- lib/kameleoon/targeting/conditions/custom_datum.rb
+- lib/kameleoon/targeting/models.rb
+- lib/kameleoon/targeting/tree_builder.rb
+- lib/kameleoon/utils.rb
+homepage: https://developers.kameleoon.com/ruby-sdk.html
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Kameleoon Client Ruby SDK
+test_files: []