kameleoon-client-ruby 2.1.0 → 2.1.1

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

data/lib/kameleoon/request.rb

@@ -7,27 +7,24 @@ module Kameleoon
   module Request
     protected
 
-    API_URL = 'https://api.kameleoon.com'.freeze
-    CLIENT_CONFIG_URL = 'https://client-config.kameleoon.com'.freeze
-
     module Method
       GET = 'get'.freeze
       POST = 'post'.freeze
     end
 
-    def get(request_options, url = API_URL, connexion_options = {})
+    def get(request_options, url, connexion_options = {})
       request(Method::GET, request_options, url, connexion_options)
     end
 
-    def post(request_options, url = API_URL, connexion_options = {})
+    def post(request_options, url, connexion_options = {})
       request(Method::POST, request_options, url, connexion_options)
     end
 
-    def get_sync(url = API_URL, connexion_options = {})
+    def get_sync(url, connexion_options = {})
       request_sync(Method::GET, url, connexion_options, {})
     end
 
-    def post_sync(request_options, url = API_URL, connexion_options = {})
+    def post_sync(request_options, url, connexion_options = {})
       request_sync(Method::POST, url, connexion_options, request_options)
     end
 
@@ -35,7 +32,6 @@ module Kameleoon
 
     def request(method, request_options, url, connexion_options)
       connexion_options[:tls] = { verify_peer: false }
-      add_user_agent(request_options)
       case method
         when Method::POST then
           return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
@@ -49,7 +45,6 @@ module Kameleoon
 
     def request_sync(method, url, connexion_options, request_options)
       request_options = {} if request_options.nil?
-      add_user_agent(request_options)
       case method
         when Method::GET then
           uri = URI(url)
@@ -60,7 +55,7 @@ module Kameleoon
           uri = URI.parse(url)
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true
-          request = Net::HTTP::Post.new(request_options[:path], initheader = request_options[:head])
+          request = Net::HTTP::Post.new(uri, initheader = request_options[:head])
           request.body = request_options[:body]
           response = http.request(request)
           response
@@ -77,14 +72,5 @@ module Kameleoon
     def successful_sync?(response)
       !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
     end
-
-    def add_user_agent(request_options)
-      sdk_version = "sdk/ruby/#{Kameleoon::VERSION}"
-      if request_options[:head].nil?
-        request_options[:head] = { 'Kameleoon-Client' => sdk_version }
-      else
-        request_options[:head].store('Kameleoon-Client', sdk_version)
-      end
-    end
   end
 end

data/lib/kameleoon/targeting/condition.rb

@@ -1,28 +1,57 @@
 # frozen_string_literal: true
+require 'kameleoon/exceptions'
 
 module Kameleoon
   # @api private
   module Targeting
+    module ConditionType
+      CUSTOM_DATUM = 'CUSTOM_DATUM'
+      TARGET_EXPERIMENT = 'TARGET_EXPERIMENT'
+      EXCLUSIVE_EXPERIMENT = 'EXCLUSIVE_EXPERIMENT'
+      PAGE_URL = 'PAGE_URL'
+      PAGE_TITLE = 'PAGE_TITLE'
+      VISITOR_CODE = 'VISITOR_CODE'
+      DEVICE_TYPE = 'DEVICE_TYPE'
+      BROWSER = 'BROWSER'
+      SDK_LANGUAGE = 'SDK_LANGUAGE'
+      CONVERSIONS = 'CONVERSIONS'
+    end
+
+    module Operator
+      UNDEFINED = 'UNDEFINED'
+      CONTAINS = 'CONTAINS'
+      EXACT = 'EXACT'
+      REGULAR_EXPRESSION = 'REGULAR_EXPRESSION'
+      LOWER = 'LOWER'
+      EQUAL = 'EQUAL'
+      GREATER = 'GREATER'
+      IS_TRUE = 'TRUE'
+      IS_FALSE = 'FALSE'
+      AMONG_VALUES = 'AMONG_VALUES'
+      ANY = 'ANY'
+      UNKNOWN = 'UNKNOWN'
+    end
+
+    # Base class for all targeting conditions
     class Condition
-      attr_accessor :type, :include
+      attr_reader :type, :include
 
       def initialize(json_condition)
-        if json_condition['targetingType'].nil?
-          raise Exception::NotFound.new('targetingType'), 'targetingType missed'
-        end
+        raise Exception::NotFound.new('targetingType'), 'targetingType missed' if json_condition['targetingType'].nil?
 
         @type = json_condition['targetingType']
-
-        if json_condition['include'].nil? && json_condition['isInclude'].nil?
-          raise Exception::NotFound.new('include / isInclude missed'), 'include / isInclude missed'
-        end
-
-        @include = json_condition['include'] || json_condition['isInclude']
+        @include = json_condition['isInclude'].nil? ? true : json_condition['isInclude']
       end
 
-      def check(conditions)
+      def check(_data)
         raise 'Abstract method `check` call'
       end
+
+      protected
+
+      def get_last_targeting_data(list_data, data_type)
+        list_data.select { |data| data.instance == data_type }.last
+      end
     end
   end
 end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -1,22 +1,45 @@
-require 'kameleoon/targeting/conditions/custom_datum'
-require 'kameleoon/targeting/conditions/target_experiment'
-require 'kameleoon/targeting/conditions/exclusive_experiment'
+require_relative 'conditions/custom_datum'
+require_relative 'conditions/target_experiment'
+require_relative 'conditions/exclusive_experiment'
+require_relative 'conditions/page_title_condition'
+require_relative 'conditions/page_url_condition'
+require_relative 'conditions/visitor_code_condition'
+require_relative 'conditions/device_condition'
+require_relative 'conditions/conversion_condition'
+require_relative 'conditions/browser_condition'
+require_relative 'conditions/sdk_language_condition'
+require_relative 'conditions/unknown_condition'
 
 module Kameleoon
-  #@api private
+  # @api private
   module Targeting
+    # Module for create different targeting conditions
     module ConditionFactory
       def get_condition(condition_json)
-        condition = nil
         case condition_json['targetingType']
-        when ConditionType::CUSTOM_DATUM.to_s
-          condition = CustomDatum.new(condition_json)
-        when ConditionType::TARGET_EXPERIMENT.to_s
-          condition = TargetExperiment.new(condition_json)
-        when ConditionType::EXCLUSIVE_EXPERIMENT.to_s
-          condition = ExclusiveExperiment.new(condition_json)
+        when ConditionType::CUSTOM_DATUM
+          CustomDatum.new(condition_json)
+        when ConditionType::TARGET_EXPERIMENT
+          TargetExperiment.new(condition_json)
+        when ConditionType::EXCLUSIVE_EXPERIMENT
+          ExclusiveExperiment.new(condition_json)
+        when ConditionType::PAGE_URL
+          PageUrlCondition.new(condition_json)
+        when ConditionType::PAGE_TITLE
+          PageTitleCondition.new(condition_json)
+        when ConditionType::VISITOR_CODE
+          VisitorCodeCondition.new(condition_json)
+        when ConditionType::DEVICE_TYPE
+          DeviceCondition.new(condition_json)
+        when ConditionType::CONVERSIONS
+          ConversionCondition.new(condition_json)
+        when ConditionType::BROWSER
+          BrowserCondition.new(condition_json)
+        when ConditionType::SDK_LANGUAGE
+          SdkLanguageCondition.new(condition_json)
+        else
+          UnknownCondition.new(condition_json)
         end
-        condition
       end
     end
   end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/browser'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    CHROME = 'CHROME'
+    INTERNET_EXPLORER = 'IE'
+    FIREFOX = 'FIREFOX'
+    SAFARI = 'SAFARI'
+    OPERA = 'OPERA'
+
+    # BrowserCondition is a condition for checking targeting with browser's type and version
+    class BrowserCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @browser_type = browser_index_from_name(json_condition['browser'])
+        @version = json_condition['version']
+        @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)
+      end
+
+      private
+
+      def check_targeting(browser)
+        return false if @browser_type != browser.type
+
+        return true if @version.nil?
+
+        version_number = SdkVersion.get_float_version(@version)
+        return false if version_number.nan?
+
+        case @version_match_type
+        when Operator::EQUAL
+          browser.version == version_number
+        when Operator::GREATER
+          browser.version > version_number
+        when Operator::LOWER
+          browser.version < version_number
+        else
+          puts "Unexpected comparing operation for Browser condition: #{@version_match_type}"
+          false
+        end
+      end
+
+      def browser_index_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
+        else
+          BrowserType::OTHER
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # ConversionCondition is a condition for checking targeting of conversions of visitor
+    class ConversionCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @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)
+      end
+    end
+  end
+end

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

@@ -11,90 +11,85 @@ module Kameleoon
     class CustomDatum < Condition
       include Kameleoon::Exception
 
-      def initialize(json_condition)
-        super(json_condition)
-        @index = json_condition['customDataIndex']
-
-        if json_condition['valueMatchType'].nil?
-          raise Exception::NotFound.new('valueMatchType'), 'valueMatchType missed'
+      class << self
+        def op_match(values, value)
+          re = Regexp.new(value.to_s)
+          values.any? { |v| re.match(v) }
         end
 
-        @operator = json_condition['valueMatchType']
-
-        @value = json_condition['value']
-
-        @type = ConditionType::CUSTOM_DATUM
-
-        if json_condition['include'].nil? && json_condition['isInclude'].nil?
-          raise Exception::NotFound.new('include / isInclude missed'), 'include / isInclude missed'
+        def op_contains(values, value)
+          values.any? { |v| v.to_s.include? value.to_s }
         end
 
-        @include = json_condition['include'] || json_condition['isInclude']
-
-        @op = {
-          Operator::MATCH.to_s => method(:op_match),
-          Operator::CONTAINS.to_s => method(:op_contains),
-          Operator::EXACT.to_s => method(:op_exact),
-          Operator::EQUAL.to_s => method(:op_equal),
-          Operator::GREATER.to_s => method(:op_greater),
-          Operator::LOWER.to_s => method(:op_lower),
-          Operator::IS_TRUE.to_s => method(:op_is_true),
-          Operator::IS_FALSE.to_s => method(:op_is_false),
-          Operator::AMONG_VALUES.to_s => method(:op_among_values),
-        }[@operator]
-      end
+        def op_exact(values, value)
+          values.include? value.to_s
+        end
 
-      def check(datas)
-        is_targeted = false
-        custom_data = datas.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
-          raise KameleoonError.new("Undefined operator #{@operator}"), "Undefined operator #{@operator}" if @op.nil?
+        def op_equal(values, value)
+          values.any? { |v| v.to_f == value.to_f }
+        end
 
-          is_targeted = @op.call(custom_data.values)
+        def op_greater(values, value)
+          values.any? { |v| v.to_f > value.to_f }
         end
-        is_targeted
-      end
 
-      private
+        def op_lower(values, value)
+          values.any? { |v| v.to_f < value.to_f }
+        end
 
-      def op_match(values)
-        re = Regexp.new(@value.to_s)
-        values.any? { |v| re.match(v) }
-      end
+        def op_is_true(values, _value)
+          values.any? { |v| v.to_s == 'true' }
+        end
 
-      def op_contains(values)
-        values.any? { |v| v.to_s.include? @value.to_s }
-      end
+        def op_is_false(values, _value)
+          values.any? { |v| v.to_s == 'false' }
+        end
 
-      def op_exact(values)
-        values.include? @value.to_s
+        def op_among_values(values, value)
+          all_matches = JSON.parse(value.to_s).map(&:to_s).to_set
+          values.any? { |v| all_matches.include?(v) }
+        end
       end
 
-      def op_equal(values)
-        values.any? { |v| v.to_f == @value.to_f }
-      end
+      @@op = {
+        Operator::REGULAR_EXPRESSION => method(:op_match),
+        Operator::CONTAINS => method(:op_contains),
+        Operator::EXACT => method(:op_exact),
+        Operator::EQUAL => method(:op_equal),
+        Operator::GREATER => method(:op_greater),
+        Operator::LOWER => method(:op_lower),
+        Operator::IS_TRUE => method(:op_is_true),
+        Operator::IS_FALSE => method(:op_is_false),
+        Operator::AMONG_VALUES => method(:op_among_values)
+      }
 
-      def op_greater(values)
-        values.any? { |v| v.to_f > @value.to_f }
-      end
+      def initialize(json_condition)
+        super(json_condition)
 
-      def op_lower(values)
-        values.any? { |v| v.to_f < @value.to_f }
-      end
+        if json_condition['valueMatchType'].nil?
+          raise Exception::NotFound.new('valueMatchType'), 'valueMatchType missed'
+        end
 
-      def op_is_true(values)
-        values.any? { |v| v.to_s == 'true' }
+        @type = ConditionType::CUSTOM_DATUM
+        @index = json_condition['customDataIndex']
+        @operator = json_condition['valueMatchType']
+        @value = json_condition['value']
       end
 
-      def op_is_false(values)
-        values.any? { |v| v.to_s == 'false' }
-      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}"
+          end
 
-      def op_among_values(values)
-        all_matches = JSON.parse(@value.to_s).map(&:to_s).to_set
-        values.any? { |v| all_matches.include?(v) }
+          is_targeted = @operation.call(custom_data.values, @value)
+        end
+        is_targeted
       end
     end
   end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # DeviceCondition is a condition for checking device type
+    class DeviceCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @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
+      end
+    end
+  end
+end

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

@@ -1,24 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/targeting/condition'
-require 'kameleoon/exceptions'
 
 module Kameleoon
   # @api private
   module Targeting
     # ExclusiveExperiment represents an instance of Exclusive Experiment condition in user account
     class ExclusiveExperiment < Condition
-      include Kameleoon::Exception
-
-      def initialize(json_condition)
-        if json_condition['targetingType'].nil?
-          raise Exception::NotFound.new('targetingType'), 'targetingType missed'
-        end
-
-        @type = json_condition['targetingType']
-        @include = true
-      end
-
       def check(data)
         experiment_id = data.experiment_id
         storage = data.storage

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+require_relative 'string_value_condition'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # PageTitleCondition is a condition for checking title of a page
+    class PageTitleCondition < StringValueCondition
+      def initialize(json_condition)
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+require_relative 'string_value_condition'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # PageUrlCondition is a condition for checking url of a page
+    class PageUrlCondition < StringValueCondition
+      def initialize(json_condition)
+        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)
+      end
+    end
+  end
+end