optimizely-sdk 2.0.0.beta → 2.0.0.beta1

data/lib/optimizely/notification_center.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2017, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module Optimizely
+  class NotificationCenter
+    attr_reader :notifications
+    attr_reader :notification_id
+
+    NOTIFICATION_TYPES = {
+      ACTIVATE: 'ACTIVATE: experiment, user_id, attributes, variation, event',
+      TRACK: 'TRACK: event_key, user_id, attributes, event_tags, event'
+    }.freeze
+
+    def initialize(logger, error_handler)
+      @notification_id = 1
+      @notifications = {}
+      NOTIFICATION_TYPES.each_value { |value| @notifications[value] = [] }
+      @logger = logger
+      @error_handler = error_handler
+    end
+
+    def add_notification_listener(notification_type, notification_callback)
+      # Adds notification callback to the notification center
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+      #  notification_callback: function to call when the event is sent
+
+      # Returns:
+      #  notification ID used to remove the notification
+
+      return nil unless notification_type_valid?(notification_type)
+
+      unless notification_callback
+        @logger.log Logger::ERROR, 'Callback can not be empty.'
+        return nil
+      end
+
+      unless notification_callback.is_a? Method
+        @logger.log Logger::ERROR, 'Invalid notification callback given.'
+        return nil
+      end
+
+      @notifications[notification_type].each do |notification|
+        return -1 if notification[:callback] == notification_callback
+      end
+      @notifications[notification_type].push(notification_id: @notification_id, callback: notification_callback)
+      notification_id = @notification_id
+      @notification_id += 1
+      notification_id
+    end
+
+    def remove_notification_listener(notification_id)
+      # Removes previously added notification callback
+
+      # Args:
+      #  notification_id:
+      # Returns:
+      #  The function returns true if found and removed, false otherwise
+      unless notification_id
+        @logger.log Logger::ERROR, 'Notification ID can not be empty.'
+        return nil
+      end
+      @notifications.each_key do |key|
+        @notifications[key].each do |notification|
+          if notification_id == notification[:notification_id]
+            @notifications[key].delete(notification_id: notification_id, callback: notification[:callback])
+            return true
+          end
+        end
+      end
+      false
+    end
+
+    def clear_notifications(notification_type)
+      # Removes notifications for a certain notification type
+      #
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+
+      return nil unless notification_type_valid?(notification_type)
+
+      @notifications[notification_type] = []
+      @logger.log Logger::INFO, "All callbacks for notification type #{notification_type} have been removed."
+    end
+
+    def clean_all_notifications
+      # Removes all notifications
+      @notifications.each_key { |key| @notifications[key] = [] }
+    end
+
+    def send_notifications(notification_type, *args)
+      # Sends off the notification for the specific event.  Uses var args to pass in a
+      # arbitrary list of parameters according to which notification type was sent
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+      #  args: list of arguments to the callback
+      return nil unless notification_type_valid?(notification_type)
+
+      @notifications[notification_type].each do |notification|
+        begin
+          notification_callback = notification[:callback]
+          notification_callback.call(*args)
+          @logger.log Logger::INFO, "Notification #{notification_type} sent successfully."
+        rescue => e
+          @logger.log(Logger::ERROR, "Problem calling notify callback. Error: #{e}")
+          return nil
+        end
+      end
+    end
+
+    private
+
+    def notification_type_valid?(notification_type)
+      # Validates notification type
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+
+      # Returns true if notification_type is valid,  false otherwise
+
+      unless notification_type
+        @logger.log Logger::ERROR, 'Notification type can not be empty.'
+        return false
+      end
+
+      unless @notifications.include?(notification_type)
+        @logger.log Logger::ERROR, 'Invalid notification type.'
+        @error_handler.handle_error InvalidNotificationType
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/optimizely/params.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #
-#    Copyright 2016, Optimizely and contributors
+#    Copyright 2016-2017, Optimizely and contributors
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.

data/lib/optimizely/project_config.rb

@@ -1,5 +1,6 @@
-#
-#    Copyright 2016-2017, Optimizely and contributors
+# frozen_string_literal: true
+
+#    Copyright 2016-2018, Optimizely and contributors
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -16,14 +17,13 @@
 require 'json'
 
 module Optimizely
-
   V1_CONFIG_VERSION = '1'
 
-  UNSUPPORTED_VERSIONS = [V1_CONFIG_VERSION]
+  UNSUPPORTED_VERSIONS = [V1_CONFIG_VERSION].freeze
 
   class ProjectConfig
     # Representation of the Optimizely project config.
-    RUNNING_EXPERIMENT_STATUS = ['Running']
+    RUNNING_EXPERIMENT_STATUS = ['Running'].freeze
 
     # Gets project config attributes.
     attr_reader :error_handler
@@ -38,6 +38,8 @@ module Optimizely
     attr_reader :groups
     attr_reader :parsing_succeeded
     attr_reader :project_id
+    # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
+    attr_reader :anonymize_ip
     attr_reader :revision
     attr_reader :rollouts
     attr_reader :version
@@ -56,21 +58,25 @@ module Optimizely
     attr_reader :variation_id_to_variable_usage_map
     attr_reader :variation_key_map
 
+    # Hash of user IDs to a Hash
+    # of experiments to variations. This contains all the forced variations
+    # set by the user by calling setForcedVariation (it is not the same as the
+    # whitelisting forcedVariations data structure in the Experiments class).
+    attr_reader :forced_variation_map
+
     def initialize(datafile, logger, error_handler)
       # ProjectConfig init method to fetch and set project config data
       #
       # datafile - JSON string representing the project
 
-      config = JSON.load(datafile)
+      config = JSON.parse(datafile)
 
       @parsing_succeeded = false
       @error_handler = error_handler
       @logger = logger
       @version = config['version']
 
-      if UNSUPPORTED_VERSIONS.include?(@version)
-        return
-      end
+      return if UNSUPPORTED_VERSIONS.include?(@version)
 
       @account_id = config['accountId']
       @attributes = config.fetch('attributes', [])
@@ -80,6 +86,7 @@ module Optimizely
       @feature_flags = config.fetch('featureFlags', [])
       @groups = config.fetch('groups', [])
       @project_id = config['projectId']
+      @anonymize_ip = config.key? 'anonymizeIP' ? config['anonymizeIP'] : false
       @revision = config['revision']
       @rollouts = config.fetch('rollouts', [])
 
@@ -98,9 +105,10 @@ module Optimizely
       @audience_id_map = generate_key_map(@audiences, 'id')
       @variation_id_map = {}
       @variation_key_map = {}
+      @forced_variation_map = {}
       @variation_id_to_variable_usage_map = {}
       @variation_id_to_experiment_map = {}
-      @experiment_key_map.each do |key, exp|
+      @experiment_key_map.each_value do |exp|
         # Excludes experiments from rollouts
         variations = exp.fetch('variations')
         variations.each do |variation|
@@ -111,23 +119,23 @@ module Optimizely
       @rollout_id_map = generate_key_map(@rollouts, 'id')
       # split out the experiment id map for rollouts
       @rollout_experiment_id_map = {}
-      @rollout_id_map.each do |id, rollout|
+      @rollout_id_map.each_value do |rollout|
         exps = rollout.fetch('experiments')
         @rollout_experiment_id_map = @rollout_experiment_id_map.merge(generate_key_map(exps, 'id'))
       end
       @all_experiments = @experiment_key_map.merge(@rollout_experiment_id_map)
       @all_experiments.each do |key, exp|
         variations = exp.fetch('variations')
-        @variation_id_map[key] = generate_key_map(variations, 'id')
-        @variation_key_map[key] = generate_key_map(variations, 'key')
-
         variations.each do |variation|
           variation_id = variation['id']
+          variation['featureEnabled'] = variation['featureEnabled'] == true
           variation_variables = variation['variables']
           unless variation_variables.nil?
             @variation_id_to_variable_usage_map[variation_id] = generate_key_map(variation_variables, 'id')
           end
         end
+        @variation_id_map[key] = generate_key_map(variations, 'id')
+        @variation_key_map[key] = generate_key_map(variations, 'key')
       end
       @feature_flag_key_map = generate_key_map(@feature_flags, 'key')
       @feature_variable_key_map = {}
@@ -143,7 +151,7 @@ module Optimizely
       # experiment - Experiment
       #
       # Returns true if experiment is running
-      return RUNNING_EXPERIMENT_STATUS.include?(experiment['status'])
+      RUNNING_EXPERIMENT_STATUS.include?(experiment['status'])
     end
 
     def get_experiment_from_key(experiment_key)
@@ -188,15 +196,15 @@ module Optimizely
       []
     end
 
-    def get_audience_conditions_from_id(audience_id)
-      # Get audience conditions for the provided audience ID
+    def get_audience_from_id(audience_id)
+      # Get audience for the provided audience ID
       #
       # audience_id - ID of the audience
       #
-      # Returns conditions for the audience
+      # Returns the audience
 
       audience = @audience_id_map[audience_id]
-      return audience['conditions'] if audience
+      return audience if audience
       @logger.log Logger::ERROR, "Audience '#{audience_id}' is not in datafile."
       @error_handler.handle_error InvalidAudienceError
       nil
@@ -246,12 +254,12 @@ module Optimizely
       nil
     end
 
-    def get_forced_variations(experiment_key)
-      # Retrieves forced variations for a given experiment Key
+    def get_whitelisted_variations(experiment_key)
+      # Retrieves whitelisted variations for a given experiment Key
       #
       # experiment_key - String Key representing the experiment
       #
-      # Returns forced variations for the experiment or nil
+      # Returns whitelisted variations for the experiment or nil
 
       experiment = @experiment_key_map[experiment_key]
       return experiment['forcedVariations'] if experiment
@@ -259,6 +267,102 @@ module Optimizely
       @error_handler.handle_error InvalidExperimentError
     end
 
+    def get_forced_variation(experiment_key, user_id)
+      # Gets the forced variation for the given user and experiment.
+      #
+      # experiment_key - String Key for experiment.
+      # user_id - String ID for user
+      #
+      # Returns Variation The variation which the given user and experiment should be forced into.
+
+      # check for nil and empty string user ID
+      if user_id.nil? || user_id.empty?
+        @logger.log(Logger::DEBUG, 'User ID is invalid')
+        return nil
+      end
+
+      unless @forced_variation_map.key? user_id
+        @logger.log(Logger::DEBUG, "User '#{user_id}' is not in the forced variation map.")
+        return nil
+      end
+
+      experiment_to_variation_map = @forced_variation_map[user_id]
+      experiment = get_experiment_from_key(experiment_key)
+      experiment_id = experiment['id'] if experiment
+      # check for nil and empty string experiment ID
+      if experiment_id.nil? || experiment_id.empty?
+        # this case is logged in get_experiment_from_key
+        return nil
+      end
+
+      unless experiment_to_variation_map.key? experiment_id
+        @logger.log(Logger::DEBUG, "No experiment '#{experiment_key}' mapped to user '#{user_id}' "\
+                    'in the forced variation map.')
+        return nil
+      end
+
+      variation_id = experiment_to_variation_map[experiment_id]
+      variation_key = ''
+      variation = get_variation_from_id(experiment_key, variation_id)
+      variation_key = variation['key'] if variation
+
+      # check if the variation exists in the datafile
+      if variation_key.empty?
+        # this case is logged in get_variation_from_id
+        return nil
+      end
+
+      @logger.log(Logger::DEBUG, "Variation '#{variation_key}' is mapped to experiment '#{experiment_key}' "\
+                  "and user '#{user_id}' in the forced variation map")
+
+      variation
+    end
+
+    def set_forced_variation(experiment_key, user_id, variation_key)
+      # Sets a Hash of user IDs to a Hash of experiments to forced variations.
+      #
+      # experiment_key - String Key for experiment.
+      # user_id - String ID for user.
+      # variation_key - String Key for variation. If null, then clear the existing experiment-to-variation mapping.
+      #
+      # Returns a boolean value that indicates if the set completed successfully.
+
+      #  check for null and empty string user ID
+      if user_id.nil? || user_id.empty?
+        @logger.log(Logger::DEBUG, 'User ID is invalid')
+        return false
+      end
+
+      experiment = get_experiment_from_key(experiment_key)
+      experiment_id = experiment['id'] if experiment
+      #  check if the experiment exists in the datafile
+      return false if experiment_id.nil? || experiment_id.empty?
+
+      #  clear the forced variation if the variation key is null
+      if variation_key.nil? || variation_key.empty?
+        @forced_variation_map[user_id].delete(experiment_id) if @forced_variation_map.key? user_id
+        @logger.log(Logger::DEBUG, "Variation mapped to experiment '#{experiment_key}' has been removed for user "\
+                    "'#{user_id}'.")
+        return true
+      end
+
+      variation_id = get_variation_id_from_key(experiment_key, variation_key)
+
+      #  check if the variation exists in the datafile
+      unless variation_id
+        #  this case is logged in get_variation_id_from_key
+        return false
+      end
+
+      unless @forced_variation_map.key? user_id
+        @forced_variation_map[user_id] = {}
+      end
+      @forced_variation_map[user_id][experiment_id] = variation_id
+      @logger.log(Logger::DEBUG, "Set variation '#{variation_id}' for experiment '#{experiment_id}' and "\
+                  "user '#{user_id}' in the forced variation map.")
+      true
+    end
+
     def get_attribute_id(attribute_key)
       attribute = @attribute_key_map[attribute_key]
       return attribute['id'] if attribute
@@ -290,7 +394,6 @@ module Optimizely
         return true if variation
         @logger.log Logger::ERROR, "Variation ID '#{variation_id}' is not in datafile."
         @error_handler.handle_error InvalidVariationError
-        return false
       end
 
       false
@@ -318,7 +421,8 @@ module Optimizely
       feature_flag_key = feature_flag['key']
       variable = @feature_variable_key_map[feature_flag_key][variable_key]
       return variable if variable
-      @logger.log Logger::ERROR, "No feature variable was found for key '#{variable_key}' in feature flag '#{feature_flag_key}'."
+      @logger.log Logger::ERROR, "No feature variable was found for key '#{variable_key}' in feature flag "\
+                  "'#{feature_flag_key}'."
       nil
     end
 

data/lib/optimizely/user_profile_service.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 #    Copyright 2017, Optimizely and contributors
 #

data/lib/optimizely/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 #    Copyright 2016-2017, Optimizely and contributors
 #
@@ -14,5 +16,6 @@
 #    limitations under the License.
 #
 module Optimizely
-  VERSION = '2.0.0.beta'.freeze
+  CLIENT_ENGINE = 'ruby-sdk'
+  VERSION = '2.0.0.beta1'
 end