rox-rollout 4.1.0 → 5.0.0

data/lib/rox/core/register/registerer.rb

@@ -7,25 +7,26 @@ module Rox
         @mutex = Mutex.new
       end
 
-      def register_instance(container, ns)
-        raise ArgumentError, 'A namespace cannot be null' if ns.nil?
+      def register_instance(container, namespace)
+        raise ArgumentError, 'A namespace cannot be null' if namespace.nil?
 
         @mutex.synchronize do
-          raise ArgumentError, "A container with the given namespace (#{ns}) has already been registered" if @namespaces.include?(ns)
+          if @namespaces.include?(namespace)
+            raise ArgumentError,
+                  "A container with the given namespace (#{namespace}) has already been registered"
+          end
         end
 
-        @namespaces << ns
+        @namespaces << namespace
 
-        container.instance_variables().each do |attribute_name|
+        container.instance_variables.each do |attribute_name|
           begin
             value = container.instance_variable_get(attribute_name)
-            if value != nil && value.is_a?(Variant)
-              var_name = attribute_name.to_s();
-              # removing the attribute starting @ (if [always] exists)
-              if (var_name[0] == '@')
-                var_name[0] = '';
-              end
-              @flag_repository.add_flag(value, ns == '' ? var_name : "#{ns}.#{var_name}")
+            if !value.nil? && value.is_a?(RoxString)
+              var_name = attribute_name.to_s
+            # removing the attribute starting @ (if [always] exists)
+              var_name[0] = '' if var_name[0] == '@'
+              @flag_repository.add_flag(value, namespace == '' ? var_name : "#{namespace}.#{var_name}")
             end
           rescue StandardError
             next

data/lib/rox/core/reporting/error_reporter.rb

@@ -13,6 +13,7 @@ module Rox
 
       def report(message, ex)
         return if @device_properties.rollout_environment == 'LOCAL'
+        return if @device_properties.rox_options.self_managed?
 
         Logging.logger.error("Error report: #{message}", ex)
 
@@ -33,8 +34,8 @@ module Rox
         begin
           @request.send_post(ErrorReporter::BUGSNAG_NOTIFY_URL, payload)
           Logging.logger.debug('Bugsnag error report was sent')
-        rescue StandardError => ex
-          Logging.logger.error('Failed to send bugsnag error ', ex)
+        rescue StandardError => e
+          Logging.logger.error('Failed to send bugsnag error ', e)
         end
       end
 
@@ -49,13 +50,13 @@ module Rox
 
       def add_metadata(message, ev)
         inner_data = {
-            'message' => message,
-            'deviceId' => @device_properties.distinct_id,
-            'buid' => @buid.to_s
+          'message' => message,
+          'deviceId' => @device_properties.distinct_id,
+          'buid' => @buid.to_s
         }
 
         metadata = {
-            'data' => inner_data
+          'data' => inner_data
         }
 
         ev['metaData'] = metadata
@@ -88,15 +89,15 @@ module Rox
 
       def add_notifier(payload)
         notifier = {
-            'name' => 'Rollout Ruby SDK',
-            'version' => @device_properties.lib_version
+          'name' => 'Rollout Ruby SDK',
+          'version' => @device_properties.lib_version
         }
         payload['notifier'] = notifier
       end
 
       def add_user(id, rollout_key, ev)
         user = {
-            id => rollout_key
+          id => rollout_key
         }
         ev['user'] = user
       end
@@ -121,13 +122,13 @@ module Rox
 
       def add_app(ev)
         app = {
-            'releaseStage' => @device_properties.rollout_environment,
-            'version' => @device_properties.lib_version
+          'releaseStage' => @device_properties.rollout_environment,
+          'version' => @device_properties.lib_version
         }
         ev['app'] = app
       end
 
-      STACK_TRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/
+      STACK_TRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/.freeze
 
       def parse_stack_trace(stack_trace)
         stack = []
@@ -149,4 +150,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/repositories/custom_property_repository.rb

@@ -58,4 +58,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/repositories/experiment_repository.rb

@@ -5,9 +5,7 @@ module Rox
         @experiments = []
       end
 
-      def experiments=(experiments)
-        @experiments = experiments
-      end
+      attr_writer :experiments
 
       def experiment_by_flag(flag_name)
         @experiments.detect { |e| e.flags.include?(flag_name) }
@@ -18,4 +16,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/repositories/flag_repository.rb

@@ -2,29 +2,29 @@ module Rox
   module Core
     class FlagRepository
       def initialize
-        @variants = {}
+        @strings = {}
         @flag_added_handlers = []
         @mutex = Mutex.new
         @handlers_mutex = Mutex.new
       end
 
-      def add_flag(variant, name)
-        variant.name = name if variant.name.nil? || variant.name.empty?
+      def add_flag(string, name)
+        string.name = name if string.name.nil? || string.name.empty?
         @mutex.synchronize do
-          @variants[name] = variant
+          @strings[name] = string
         end
-        raise_flag_added_event(variant)
+        raise_flag_added_event(string)
       end
 
       def flag(name)
         @mutex.synchronize do
-          return @variants[name]
+          return @strings[name]
         end
       end
 
       def all_flags
         @mutex.synchronize do
-          return @variants.values
+          return @strings.values
         end
       end
 
@@ -46,4 +46,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/repositories/roxx/experiments_extensions.rb

@@ -11,13 +11,13 @@ module Rox
       end
 
       def extend
-        @parser.add_operator('mergeSeed') do |parser, stack, context|
+        @parser.add_operator('mergeSeed') do |_parser, stack, _context|
           seed1 = stack.pop
           seed2 = stack.pop
           stack.push("#{seed1}.#{seed2}")
         end
 
-        @parser.add_operator('isInPercentage') do |parser, stack, context|
+        @parser.add_operator('isInPercentage') do |_parser, stack, _context|
           percentage = stack.pop
           seed = stack.pop
 
@@ -27,7 +27,7 @@ module Rox
           stack.push(bucket <= percentage)
         end
 
-        @parser.add_operator('isInPercentageRange') do |parser, stack, context|
+        @parser.add_operator('isInPercentageRange') do |_parser, stack, _context|
           percentage_low = stack.pop
           percentage_high = stack.pop
           seed = stack.pop
@@ -42,17 +42,17 @@ module Rox
         @parser.add_operator('flagValue') do |parser, stack, context|
           feature_flag_identifier = stack.pop
           result = Flag::FLAG_FALSE_VALUE
-          variant = @flags_repository.flag(feature_flag_identifier)
+          string = @flags_repository.flag(feature_flag_identifier)
 
-          if !variant.nil?
-            result = variant.value(context)
-          else
+          if string.nil?
             flags_experiment = @experiment_repository.experiment_by_flag(feature_flag_identifier)
 
             if !flags_experiment.nil? && !flags_experiment.condition.nil? && !flags_experiment.condition.empty?
               experiment_eval_result = parser.evaluate_expression(flags_experiment.condition, context).string_value
               result = experiment_eval_result if !experiment_eval_result.nil? && !experiment_eval_result.empty?
             end
+          else
+            result = string.value(context)
           end
 
           stack.push(result)
@@ -79,4 +79,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/repositories/roxx/properties_extensions.rb

@@ -1,26 +1,51 @@
 require 'rox/core/roxx/token_type'
+require 'rox/core/error_handling/exception_trigger'
+require 'rox/core/error_handling/userspace_handler_exception'
 
 module Rox
   module Core
     class PropertiesExtensions
-      def initialize(parser, properties_repository)
+      def initialize(parser, properties_repository, dynamic_property_rule_handler = nil)
         @parser = parser
         @properties_repository = properties_repository
+        @dynamic_property_rule_handler = dynamic_property_rule_handler
       end
 
       def extend
-        @parser.add_operator('property') do |parser, stack, context|
+        @parser.add_operator('property') do |_parser, stack, context|
           prop_name = stack.pop.to_s
           property = @properties_repository.custom_property(prop_name)
+          value = get_value(prop_name, property, context)
 
-          if property.nil?
-            stack.push(TokenType::UNDEFINED)
+          stack.push(value.nil? ? TokenType::UNDEFINED : value)
+        end
+      end
+
+      private
+
+      def get_value(prop_name, property, context)
+        if property.nil?
+          if @dynamic_property_rule_handler.nil?
+            TokenType::UNDEFINED
           else
-            value = property.value(context)
-            stack.push(value.nil? ? TokenType::UNDEFINED : value)
+            get_value_from_dynamic_property_rule_handler(prop_name, context)
           end
+        else
+          get_value_from_property(property, context)
         end
       end
+
+      def get_value_from_dynamic_property_rule_handler(prop_name, context)
+        @dynamic_property_rule_handler.call(prop_name, context)
+      rescue StandardError => e
+        raise Rox::Core::UserspaceHandlerException, handler, ExceptionTrigger::DYNAMIC_PROPERTIES_RULE, e
+      end
+
+      def get_value_from_property(property, context)
+        property.value(context)
+      rescue StandardError => e
+        raise Rox::Core::UserspaceHandlerException, handler, ExceptionTrigger::CUSTOM_PROPERTY_GENERATOR, e
+      end
     end
   end
-end
+end

data/lib/rox/core/repositories/target_group_repository.rb

@@ -5,13 +5,11 @@ module Rox
         @target_groups = []
       end
 
-      def target_groups=(target_groups)
-        @target_groups = target_groups
-      end
+      attr_writer :target_groups
 
       def target_group(id)
         @target_groups.detect { |g| g.id == id }
       end
     end
   end
-end
+end

data/lib/rox/core/roxx/evaluation_result.rb

@@ -13,6 +13,7 @@ module Rox
       def bool_value
         return false if value.nil?
         return value if Utils.boolean?(value)
+
         nil
       end
 
@@ -21,6 +22,7 @@ module Rox
         return nil if value.nil?
         return Flag::FLAG_TRUE_VALUE if value
         return Flag::FLAG_FALSE_VALUE unless value
+
         nil
       end
     end

data/lib/rox/core/roxx/node.rb

@@ -8,4 +8,4 @@ module Rox
       UNKNOWN = 'Unknown'.freeze
     end
   end
-end
+end

data/lib/rox/core/roxx/parser.rb

@@ -1,4 +1,5 @@
 require 'digest'
+require 'base64'
 require 'rox/core/roxx/core_stack'
 require 'rox/core/roxx/evaluation_result'
 require 'rox/core/roxx/value_compare_extensions'
@@ -6,19 +7,24 @@ require 'rox/core/roxx/regular_expression_extensions'
 require 'rox/core/roxx/tokenized_expression'
 require 'rox/core/utils/type_utils'
 require 'rox/core/logging/logging'
+require 'rox/core/error_handling/userspace_handler_exception'
 
 module Rox
   module Core
     class Parser
-      def initialize
+      attr_accessor :global_context
+
+      def initialize(user_unhandled_error_invoker)
         @operators_map = {}
+        @global_context = nil
         set_basic_operators
+        @user_unhandled_error_invoker = user_unhandled_error_invoker
         ValueCompareExtensions.new(self).extend
         RegularExpressionExtensions.new(self).extend
       end
 
-      def add_operator(oper, &block)
-        @operators_map[oper] = block
+      def add_operator(operator, &block)
+        @operators_map[operator] = block
       end
 
       def evaluate_expression(expression, context = nil)
@@ -28,11 +34,12 @@ module Rox
         begin
           reverse_tokens.each do |token|
             node = token
-            if node.type == NodeTypes::RAND
+            case node.type
+            when NodeTypes::RAND
               stack.push(node.value)
-            elsif node.type == NodeTypes::RATOR
+            when NodeTypes::RATOR
               handler = @operators_map[node.value]
-              handler.call(self, stack, context) unless handler.nil?
+              handler&.call(self, stack, context)
             else
               return EvaluationResult.new(nil)
             end
@@ -42,14 +49,18 @@ module Rox
           result = nil if result == TokenType::UNDEFINED
 
           EvaluationResult.new(result)
-        rescue StandardError => ex
-          Logging.logger.warn("Roxx Exception: Failed evaluate expression: #{ex}")
+        rescue Rox::Core::UserspaceHandlerException => e
+          @user_unhandled_error_invoker.invoke(e.exception_source, e.exception_trigger, e.exception)
+          Logging.logger.warn("Roxx Exception: Failed evaluate expression, user unhandled expression: #{e}")
+          EvaluationResult.new(nil)
+        rescue StandardError => e
+          Logging.logger.warn("Roxx Exception: Failed evaluate expression: #{e}")
           EvaluationResult.new(nil)
         end
       end
 
       def set_basic_operators
-        add_operator('isUndefined') do |parser, stack, context|
+        add_operator('isUndefined') do |_parser, stack, _context|
           op1 = stack.pop
           if op1.is_a?(TokenType)
             stack.push(op1 == TokenType::UNDEFINED)
@@ -58,29 +69,31 @@ module Rox
           end
         end
 
-        add_operator('now') do |parser, stack, context|
+        add_operator('now') do |_parser, stack, _context|
           stack.push((Time.now.to_f * 1000).to_i)
         end
 
-        add_operator('and') do |parser, stack, context|
+        add_operator('and') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           op1 = false if op1 == TokenType::UNDEFINED
           op2 = false if op2 == TokenType::UNDEFINED
           raise ArgumentError, 'should be boolean' unless Utils.boolean?(op1) && Utils.boolean?(op2)
+
           stack.push(op1 && op2)
         end
 
-        add_operator('or') do |parser, stack, context|
+        add_operator('or') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           op1 = false if op1 == TokenType::UNDEFINED
           op2 = false if op2 == TokenType::UNDEFINED
           raise ArgumentError, 'should be boolean' unless Utils.boolean?(op1) && Utils.boolean?(op2)
+
           stack.push(op1 || op2)
         end
 
-        add_operator('ne') do |parser, stack, context|
+        add_operator('ne') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           op1 = false if op1 == TokenType::UNDEFINED
@@ -88,7 +101,7 @@ module Rox
           stack.push(op1 != op2)
         end
 
-        add_operator('eq') do |parser, stack, context|
+        add_operator('eq') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           op1 = false if op1 == TokenType::UNDEFINED
@@ -96,18 +109,20 @@ module Rox
           stack.push(op1 == op2)
         end
 
-        add_operator('not') do |parser, stack, context|
+        add_operator('not') do |_parser, stack, _context|
           op1 = stack.pop
           op1 = false if op1 == TokenType::UNDEFINED
           raise ArgumentError, 'should be boolean' unless Utils.boolean?(op1)
+
           stack.push(!op1)
         end
 
-        add_operator('ifThen') do |parser, stack, context|
+        add_operator('ifThen') do |_parser, stack, _context|
           condition_expression = stack.pop
           true_expression = stack.pop
           false_expression = stack.pop
           raise ArgumentError, 'should be boolean' unless Utils.boolean?(condition_expression)
+
           if condition_expression
             stack.push(true_expression)
           else
@@ -115,7 +130,7 @@ module Rox
           end
         end
 
-        add_operator('inArray') do |parser, stack, context|
+        add_operator('inArray') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           if op2.is_a?(Array)
@@ -125,7 +140,7 @@ module Rox
           end
         end
 
-        add_operator('md5') do |parser, stack, context|
+        add_operator('md5') do |_parser, stack, _context|
           op1 = stack.pop
           if op1.is_a?(String)
             stack.push(Digest::MD5.hexdigest(op1))
@@ -134,7 +149,7 @@ module Rox
           end
         end
 
-        add_operator('concat') do |parser, stack, context|
+        add_operator('concat') do |_parser, stack, _context|
           op1 = stack.pop
           op2 = stack.pop
           if op1.is_a?(String) && op2.is_a?(String)
@@ -143,7 +158,18 @@ module Rox
             stack.push(TokenType::UNDEFINED)
           end
         end
+
+        add_operator('b64d') do |_parser, stack, _context|
+          op1 = stack.pop
+          if op1.is_a?(String)
+            decoded = Base64.decode64(op1)
+            decoded = decoded.force_encoding('UTF-8')
+            stack.push(decoded)
+          else
+            stack.push(TokenType::UNDEFINED)
+          end
+        end
       end
     end
   end
-end
+end