rox-rollout 0.1.3

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

@@ -0,0 +1,26 @@
+require 'rox/core/roxx/token_type'
+
+module Rox
+  module Core
+    class PropertiesExtensions
+      def initialize(parser, properties_repository)
+        @parser = parser
+        @properties_repository = properties_repository
+      end
+
+      def extend
+        @parser.add_operator('property') do |parser, stack, context|
+          prop_name = stack.pop.to_s
+          property = @properties_repository.custom_property(prop_name)
+
+          if property.nil?
+            stack.push(TokenType::UNDEFINED)
+          else
+            value = property.value(context)
+            stack.push(value.nil? ? TokenType::UNDEFINED : value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Rox
+  module Core
+    class TargetGroupRepository
+      def initialize
+        @target_groups = []
+      end
+
+      def target_groups=(target_groups)
+        @target_groups = target_groups
+      end
+
+      def target_group(id)
+        @target_groups.detect { |g| g.id == id }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rox
+  module Core
+    class CoreStack
+      def initialize
+        @items = []
+      end
+
+      def push(item)
+        @items << item
+        nil
+      end
+
+      def pop
+        @items.pop
+      end
+
+      def peek
+        @items[-1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'rox/core/entities/flag'
+require 'rox/core/utils/type_utils'
+
+module Rox
+  module Core
+    class EvaluationResult
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def bool_value
+        return false if value.nil?
+        return value if Utils.boolean?(value)
+        nil
+      end
+
+      def string_value
+        return value if value.is_a? String
+        return nil if value.nil?
+        return Flag::FLAG_TRUE_VALUE if value
+        return Flag::FLAG_FALSE_VALUE unless value
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Rox
+  module Core
+    Node = Struct.new(:type, :value)
+
+    module NodeTypes
+      RAND = 'Rand'.freeze
+      RATOR = 'Rator'.freeze
+      UNKNOWN = 'Unknown'.freeze
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'digest'
+require 'rox/core/roxx/core_stack'
+require 'rox/core/roxx/evaluation_result'
+require 'rox/core/roxx/value_compare_extensions'
+require 'rox/core/roxx/regular_expression_extensions'
+require 'rox/core/roxx/tokenized_expression'
+require 'rox/core/utils/type_utils'
+require 'rox/core/logging/logging'
+
+module Rox
+  module Core
+    class Parser
+      def initialize
+        @operators_map = {}
+        set_basic_operators
+        ValueCompareExtensions.new(self).extend
+        RegularExpressionExtensions.new(self).extend
+      end
+
+      def add_operator(oper, &block)
+        @operators_map[oper] = block
+      end
+
+      def evaluate_expression(expression, context = nil)
+        stack = CoreStack.new
+        tokens = TokenizedExpression.new(expression, @operators_map.keys).tokens
+        reverse_tokens = tokens.reverse
+        begin
+          reverse_tokens.each do |token|
+            node = token
+            if node.type == NodeTypes::RAND
+              stack.push(node.value)
+            elsif node.type == NodeTypes::RATOR
+              handler = @operators_map[node.value]
+              handler.call(self, stack, context) unless handler.nil?
+            else
+              return EvaluationResult.new(nil)
+            end
+          end
+
+          result = stack.pop
+          result = nil if result == TokenType::UNDEFINED
+
+          EvaluationResult.new(result)
+        rescue StandardError => ex
+          Logging.logger.warn("Roxx Exception: Failed evaluate expression: #{ex}")
+          EvaluationResult.new(nil)
+        end
+      end
+
+      def set_basic_operators
+        add_operator('isUndefined') do |parser, stack, context|
+          op1 = stack.pop
+          if op1.is_a?(TokenType)
+            stack.push(op1 == TokenType::UNDEFINED)
+          else
+            stack.push(false)
+          end
+        end
+
+        add_operator('now') do |parser, stack, context|
+          stack.push((Time.now.to_f * 1000).to_i)
+        end
+
+        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|
+          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|
+          op1 = stack.pop
+          op2 = stack.pop
+          op1 = false if op1 == TokenType::UNDEFINED
+          op2 = false if op2 == TokenType::UNDEFINED
+          stack.push(op1 != op2)
+        end
+
+        add_operator('eq') do |parser, stack, context|
+          op1 = stack.pop
+          op2 = stack.pop
+          op1 = false if op1 == TokenType::UNDEFINED
+          op2 = false if op2 == TokenType::UNDEFINED
+          stack.push(op1 == op2)
+        end
+
+        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|
+          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
+            stack.push(false_expression)
+          end
+        end
+
+        add_operator('inArray') do |parser, stack, context|
+          op1 = stack.pop
+          op2 = stack.pop
+          if op2.is_a?(Array)
+            stack.push(op2.include?(op1))
+          else
+            stack.push(false)
+          end
+        end
+
+        add_operator('md5') do |parser, stack, context|
+          op1 = stack.pop
+          raise ArgumentError, 'should be string' unless op1.is_a?(String)
+          stack.push(Digest::MD5.hexdigest(op1))
+        end
+
+        add_operator('concat') do |parser, stack, context|
+          op1 = stack.pop
+          op2 = stack.pop
+          raise ArgumentError, 'should be string' unless op1.is_a?(String) && op2.is_a?(String)
+          stack.push("#{op1}#{op2}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Rox
+  module Core
+    class RegularExpressionExtensions
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def extend
+        @parser.add_operator('match') do |parser, stack, context|
+          text = stack.pop
+          pattern = stack.pop
+          flags = stack.pop
+          raise ArgumentError, 'should be string' unless text.is_a?(String) && pattern.is_a?(String) && flags.is_a?(String)
+
+          options = 0
+          flags.each_char do |flag|
+            case flag
+            when 'i'
+              options |= Regexp::IGNORECASE
+            when 'x'
+              options |= Regexp::EXTENDED
+            when 'm'
+              options |= Regexp::MULTILINE
+            end
+          end
+
+          matched = !Regexp.new(pattern, options).match(text).nil?
+          stack.push(matched)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Rox
+  module Core
+    class StringTokenizer
+      def initialize(text, delim, return_delims)
+        @current_position = 0
+        @new_position = -1
+        @text = text
+        @max_position = text.length
+        @delimiters = delim
+        @ret_delims = return_delims
+      end
+
+      def skip_delimiters(start_pos)
+        raise ArgumentError, 'delimiters is nil' if @delimiters.nil?
+
+        position = start_pos
+        while !@ret_delims && position < @max_position
+          c = @text[position]
+          break unless delimiter?(c)
+          position += 1
+        end
+        position
+      end
+
+      def scan_token(start_pos)
+        position = start_pos
+        while position < @max_position
+          c = @text[position]
+          break if delimiter?(c)
+          position += 1
+        end
+
+        if @ret_delims && start_pos == position
+          c = @text[position]
+          position += 1 if delimiter?(c)
+        end
+
+        position
+      end
+
+      def delimiter?(char)
+        @delimiters.include?(char)
+      end
+
+      def more_tokens?
+        @new_position = skip_delimiters(@current_position)
+        @new_position < @max_position
+      end
+
+      def next_token(delim = nil)
+        delims_changed = false
+        unless delim.nil?
+          @delimiters = delim
+          delims_changed = true
+        end
+
+        @current_position = @new_position >= 0 && !delims_changed ? @new_position : skip_delimiters(@current_position)
+        @new_position = -1
+
+        raise ArgumentError, 'invalid operation' if @current_position >= @max_position
+
+        start = @current_position
+        @current_position = scan_token(@current_position)
+        @text[start...@current_position]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Rox
+  module Core
+    module Symbols
+      ROXX_UNDEFINED = 'undefined'.freeze
+      ROXX_TRUE = 'true'.freeze
+      ROXX_FALSE = 'false'.freeze
+      ROXX_EMPTY_STRING = '""'.freeze
+      ROXX_STRING_TYPE = 'StringType'.freeze
+      ROXX_BOOL_TYPE = 'BooleanType'.freeze
+      ROXX_NUMBER_TYPE = 'NumberType'.freeze
+      ROXX_UNDEFINED_TYPE = 'UndefinedType'.freeze
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'rox/core/roxx/symbols'
+
+module Rox
+  module Core
+    class TokenType
+      attr_accessor :text, :pattern
+
+      def self.from_token(token)
+        unless token.nil?
+          tested_token = token.downcase
+          [TokenType::STRING, TokenType::NUMBER, TokenType::BOOLEAN, TokenType::UNDEFINED].each do |token_type|
+            return token_type unless token_type.pattern.match(tested_token).nil?
+          end
+        end
+        TokenType::NOT_A_TYPE
+      end
+
+      def initialize(text, pattern)
+        @text = text
+        @pattern = Regexp.new(pattern)
+      end
+
+      NOT_A_TYPE = TokenType.new('NOT_A_TYPE', '')
+      STRING = TokenType.new(Symbols::ROXX_STRING_TYPE, '"((\\\\.)|[^\\\\"])*"')
+      NUMBER = TokenType.new(Symbols::ROXX_NUMBER_TYPE, '[\\-]{0,1}\\d+[\\.]\\d+|[\\-]{0,1}\\d+')
+      BOOLEAN = TokenType.new(Symbols::ROXX_BOOL_TYPE, "#{Symbols::ROXX_TRUE}|#{Symbols::ROXX_FALSE}")
+      UNDEFINED = TokenType.new(Symbols::ROXX_UNDEFINED_TYPE, Symbols::ROXX_UNDEFINED)
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+require 'rox/core/roxx/string_tokenizer'
+require 'rox/core/roxx/node'
+require 'rox/core/roxx/symbols'
+require 'rox/core/roxx/token_type'
+
+module Rox
+  module Core
+    class TokenizedExpression
+      DICT_START_DELIMITER = '{'.freeze
+      DICT_END_DELIMITER = '}'.freeze
+      ARRAY_START_DELIMITER = '['.freeze
+      ARRAY_END_DELIMITER = ']'.freeze
+      TOKEN_DELIMITERS = "{}[]():, \t\r\n\"".freeze
+      PRE_POST_STRING_CHAR = ''.freeze
+      STRING_DELIMITER = '"'.freeze
+      ESCAPED_QUOTE = '\\"'.freeze
+      ESCAPED_QUOTE_PLACEHOLDER = '\\RO_Q'.freeze
+
+      def initialize(expression, operators)
+        @expression = expression
+        @operators = operators
+        @result_list = nil
+        @array_accumulator = nil
+        @dict_accumulator = nil
+        @dict_key = nil
+      end
+
+      def tokens
+        tokenize(@expression)
+      end
+
+      def push_node(node)
+        if !@dict_accumulator.nil? && @dict_key.nil?
+          @dict_key = node.value.to_s
+        elsif !@dict_accumulator.nil? && !@dict_key.nil?
+          @dict_accumulator[@dict_key] = node.value
+          @dict_key = nil
+        elsif !@array_accumulator.nil?
+          @array_accumulator << node.value
+        else
+          @result_list << node
+        end
+      end
+
+      def tokenize(expression)
+        @result_list = []
+        @array_accumulator = nil
+        @dict_accumulator = nil
+        @dict_key = nil
+
+        delimiters_to_use = TokenizedExpression::TOKEN_DELIMITERS
+        normalized_expression = expression.gsub(TokenizedExpression::ESCAPED_QUOTE, TokenizedExpression::ESCAPED_QUOTE_PLACEHOLDER)
+        tokenizer = StringTokenizer.new(normalized_expression, delimiters_to_use, true)
+
+        token = nil
+        while tokenizer.more_tokens?
+          prev_token = token
+          token = tokenizer.next_token(delimiters_to_use)
+          in_string = delimiters_to_use == TokenizedExpression::STRING_DELIMITER
+
+          if !in_string && token == TokenizedExpression::DICT_START_DELIMITER
+            @dict_accumulator = {}
+          elsif !in_string && token == TokenizedExpression::DICT_END_DELIMITER
+            dict_result = @dict_accumulator
+            @dict_accumulator = nil
+            push_node(node_from_dict(dict_result))
+          elsif !in_string && token == TokenizedExpression::ARRAY_START_DELIMITER
+            @array_accumulator = []
+          elsif !in_string && token == TokenizedExpression::ARRAY_END_DELIMITER
+            array_result = @array_accumulator
+            @array_accumulator = nil
+            push_node(node_from_array(array_result))
+          elsif token == TokenizedExpression::STRING_DELIMITER
+            push_node(node_from_token(Symbols::ROXX_EMPTY_STRING)) if prev_token == TokenizedExpression::STRING_DELIMITER
+            delimiters_to_use = in_string ? TokenizedExpression::TOKEN_DELIMITERS : TokenizedExpression::STRING_DELIMITER
+          else
+            if delimiters_to_use == TokenizedExpression::STRING_DELIMITER
+              push_node(Node.new(NodeTypes::RAND, token.gsub(TokenizedExpression::ESCAPED_QUOTE_PLACEHOLDER, TokenizedExpression::ESCAPED_QUOTE)))
+            elsif !TokenizedExpression::TOKEN_DELIMITERS.include?(token) && token != TokenizedExpression::PRE_POST_STRING_CHAR
+              push_node(node_from_token(token))
+            end
+          end
+        end
+
+        @result_list
+      end
+
+      def node_from_array(items)
+        Node.new(NodeTypes::RAND, items)
+      end
+
+      def node_from_dict(items)
+        Node.new(NodeTypes::RAND, items)
+      end
+
+      def node_from_token(token)
+        return Node.new(NodeTypes::RATOR, token) if @operators.include?(token)
+        return Node.new(NodeTypes::RAND, true) if token == Symbols::ROXX_TRUE
+        return Node.new(NodeTypes::RAND, false) if token == Symbols::ROXX_FALSE
+        return Node.new(NodeTypes::RAND, TokenType::UNDEFINED) if token == Symbols::ROXX_UNDEFINED
+
+        token_type = TokenType.from_token(token)
+        return Node.new(NodeTypes::RAND, token[1...-1]) if token_type == TokenType::STRING
+        if token_type == TokenType::NUMBER
+          begin
+            return Node.new(NodeTypes::RAND, Integer(token))
+          rescue ArgumentError
+            begin
+              return Node.new(NodeTypes::RAND, Float(token))
+            rescue ArgumentError => ex
+              raise ArgumentError, "Excepted Number, got '#{token}' (#{token_type}): #{ex}"
+            end
+          end
+        end
+        Node.new(NodeTypes::UNKNOWN, nil)
+      end
+    end
+  end
+end