rox-rollout 0.1.3

data/_archive/lib/function_token.rb

@@ -0,0 +1,12 @@
+
+class FunctionToken
+  attr :name
+  attr :stack_index #to paste value of this function
+
+  def initialize(name, stack_index)
+    @name = name
+    @stack_index = stack_index
+  end
+
+end
+

data/_archive/lib/object_extends.rb

@@ -0,0 +1,12 @@
+
+class Object
+  FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF', 'no', 'NO', 'undefined'].to_set
+
+  def to_boolean
+    if self.to_s == ''
+      nil
+    else
+      !FALSE_VALUES.include?(self.to_s)
+    end
+  end
+end

data/_archive/lib/ruby_interpreter.rb

@@ -0,0 +1,292 @@
+require 'pry'
+require_relative 'object_extends'
+require_relative 'string_extends'
+require_relative 'function_token'
+require_relative 'function_definition'
+require_relative 'expr_function_definition'
+
+class Expression
+  attr :expr, :stack
+
+  def initialize(expr_val, stack)
+    @expr = expr_val
+    @stack = stack
+  end
+
+  def evaluate
+  end
+
+  def to_s
+    @expr
+  end
+end
+
+class ValueExpression < Expression
+  def evaluate
+    @expr
+  end
+end
+
+class UndefinedValue < ValueExpression
+end
+
+class StringValue < ValueExpression
+end
+
+class BooleanValue < ValueExpression
+  def evaluate
+    @expr.to_boolean
+  end
+end
+
+class FloatValue < ValueExpression
+  def evaluate
+    @expr
+  end
+end
+
+class FunctionExpression < Expression
+  extend ExprFunctionDefinition
+
+  attr :evaluators
+
+  unary_bool_func :not, '!'
+
+  bool_func :and, '&'
+  bool_func :or, '|'
+
+  comp_func :eq, '=='
+  comp_func :ne, '!='
+  comp_func :lt, '<'
+  comp_func :lte, '<='
+  comp_func :gt, '>'
+  comp_func :gte, '>='
+
+  def initialize(expr_val, stack)
+    super(expr_val, stack)
+
+    @functions = ['isUndefined', 'now']
+    @functions << self.class.instance_variable_get('@func_list') 
+    @functions.flatten!
+
+    prepare_evaluators()
+  end
+
+  def evaluate
+    ev = @evaluators[@expr]
+    return ev.call unless ev.nil?
+
+#todo log invalid function 
+    @stack.push BooleanValue.new(false, @stack) if ev.nil?
+  end
+
+  private
+
+  def prepare_evaluators()
+    @evaluators = @functions.map{|f| [f, ->{ self.send("evaluate_#{f}")}]}.to_h
+  end
+
+  def evaluate_isUndefined
+    a = @stack.pop
+    @stack.push BooleanValue.new(a.evaluate == :undefined, @stack)
+  end
+
+  def evaluate_now
+    Time.now.to_f.round(3)*1000
+  end
+
+end
+
+## RubyInterpreter ##
+#
+# goal: Interpret expression in forward polish notation with some functions
+#
+class RubyInterpreter
+  extend FunctionDefinition
+
+  attr_reader :func_stack, :operands_stack
+  attr_reader :expr_stack
+
+#operators
+  unary_bool_func :not, '!'
+
+  bool_func :and, '&'
+  bool_func :or, '|'
+
+  comp_func :eq, '=='
+  comp_func :ne, '!='
+
+  comp_func :lt, '<'
+  comp_func :lte, '<='
+  comp_func :gt, '>'
+  comp_func :gte, '>='
+
+  def initialize
+    @func_stack = Stack.new
+    @operands_stack = Stack.new
+    @expr_stack = Stack.new
+
+    @func_list ||= []
+    @func_list << self.class.instance_variable_get('@func_list')
+    @func_list << ['isUndefined', 'now']
+    @func_list.flatten!
+
+    @funcs_re ||= Regexp.new(@func_list.join('|') )
+  end
+#todo make unary/2ry functions by define_method (dry code)
+
+  def prepare_expr_stack(tokens)
+    is_string_token = false
+    string_token = ''
+
+    tokens.each do |tkn, i|
+
+      if is_string_token && tkn != '"'
+        string_token += tkn
+        next
+      end
+
+      case tkn 
+        when 'undefined'
+          @expr_stack.push( UndefinedValue.new(tkn.to_sym, @expr_stack) )
+        when '"'
+          if( is_string_token ) #todo check pair "
+            is_string_token = false
+            @expr_stack.push StringValue.new(string_token, @expr_stack)
+            string_token = ''
+          else
+            is_string_token = true
+          end
+        when ',' , '(', ')', ' '
+          #do nothing
+        when @funcs_re 
+          @expr_stack.push( FunctionExpression.new( tkn , @expr_stack) )
+        when 'true', 'false'
+          @expr_stack.push BooleanValue.new(tkn, @expr_stack)
+        else
+          fval, is_float = tkn.to_float
+          if(is_float)
+            @expr_stack.push FloatValue.new(fval, @expr_stack) 
+          else
+#todo show error message 'unknown token'
+            return 'false'
+          end
+      end
+    end
+  end
+
+  def evaluate_expr_stack()
+    @func_evaluators = @func_list.map{|f| [f, ->(){ self.send("evaluate_func_#{f}")}]}.to_h
+  
+    value = false
+
+    while !@expr_stack.empty? do
+        expr = @expr_stack.pop
+        value = expr.evaluate unless expr.nil?
+
+        return false if expr.nil? #todo show error message
+    end
+
+    value
+  end
+
+
+  def evaluateExpression2(expr)
+    @expr_stack.clear
+
+    tokens = expr.scan(/\d+\.?\d*|\s+|,|\(|"|\)|\w+|\W+/)
+
+    prepare_expr_stack(tokens)
+    expr_stack.invert()
+    evaluate_expr_stack()
+  end
+
+  # Evaluate expression 
+  #
+  # info:
+  #  1. Language is polish forward notation with custom functions
+  #  2. Function list:
+  #     a. and(a,b)
+  #
+  def evaluateExpression(expr)
+    @func_stack.clear
+    @operands_stack.clear
+
+
+    tokens = expr.scan(/\d+\.?\d*|\s+|,|\(|"|\)|\w+|\W+/)
+
+    is_string_token = false
+    string_token = ''
+
+    @funcs_re ||= Regexp.new(@func_list.join('|') )
+
+    #prepare stack
+    tokens.each do |tkn, i|
+      if is_string_token && tkn != '"'
+        string_token += tkn
+        next
+      end
+
+      case tkn 
+        when 'undefined'
+          @operands_stack.push( tkn.to_sym )
+        when '"'
+          if( is_string_token ) #todo check pair "
+            is_string_token = false
+            @operands_stack.push string_token
+            string_token = ''
+          else
+            is_string_token = true
+          end
+        when ',' , '(', ')', ' '
+          #do nothing
+        when @funcs_re 
+          @func_stack.push( FunctionToken.new( tkn, @operands_stack.size ) )
+        when 'true', 'false'
+          @operands_stack.push tkn
+        else
+          fval, is_float = tkn.to_float
+          if(is_float)
+            @operands_stack.push(fval) 
+          else
+#todo show error message 'unknown token'
+            return 'false'
+          end
+      end
+    end
+
+    #evaluate stack
+    @func_evals ||= prepare_func_evaluators()
+
+    while !@func_stack.empty? do
+
+      token = @func_stack.pop
+
+      feval = @func_evals[token.name]
+
+      feval.call(token.stack_index) unless feval.nil?
+    end
+
+    @operands_stack.pop
+  end
+
+  private
+
+  def prepare_func_evaluators()
+    # make hash with functors: 'or' => ->(stack_index){ self.send('evaluateOr', stack_index) }
+    return @func_list.map{|f| [f, ->(stack_index){ self.send("evaluate#{f[0].upcase}#{f[1..-1]}", stack_index) }]}.to_h
+  end
+
+#evaluators
+
+  def evaluateIsUndefined(stack_index)
+    a = @operands_stack.pop
+    @operands_stack.push (a == :undefined).to_s
+  end
+
+  def evaluateNow(stack_index)
+    @operands_stack.insert Time.now().tv_sec.to_f, stack_index
+  end
+
+
+end

data/_archive/lib/stack.rb

@@ -0,0 +1,48 @@
+class Stack
+  
+  class EmptyError < StandardError
+  end
+
+  def initialize
+    @elements = [] 
+  end
+
+  def push(value)
+    @elements.push value
+    value
+  end
+
+  def pop
+    raise EmptyError.new('Stack is empty') if empty?
+
+    @elements.pop 
+  end
+
+  def poke(value, index)
+    @elements[index] = value
+  end
+
+  def insert(value, index)
+    @elements.insert(index, value)
+  end
+
+  def clear
+    @elements.clear
+  end
+
+  def empty?
+    @elements.size == 0
+  end
+
+  def to_s
+    @elements.join(',')
+  end
+
+  def size
+    @elements.size
+  end
+
+  def invert
+    @elements.reverse!
+  end
+end

data/_archive/lib/string_extends.rb

@@ -0,0 +1,14 @@
+
+class String
+  # convert string to float
+  #
+  # retval: 
+  #   val - float value (or nan? if not float)
+  #   is_float - bool if val is float 
+  #
+  def to_float
+    fval = 0.0
+    fval = Float(self) rescue 0.0/0.0 
+    return fval, !fval.nan?
+  end
+end

data/_archive/spec/ruby_interpreter_spec.rb

@@ -0,0 +1,203 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'RubyInterpreter' do
+  let(:parser){ RubyInterpreter.new }
+
+  def check_parser_clean
+    expect(parser.operands_stack.empty?).to eq(true)
+    expect(parser.func_stack.empty?).to eq(true)
+  end
+
+  def check_parsing(expr, result)
+    expect(parser.evaluateExpression(expr)).to eq(result)
+    check_parser_clean
+  end
+
+  def check_parser_clean2
+    expect(parser.expr_stack.empty?).to eq(true)
+  end
+
+  def check_parsing2(expr, result)
+    expect(parser.evaluateExpression2(expr)).to eq(result)
+    check_parser_clean2
+  end
+
+  context 'and function' do
+    it 'checks and(true,true) == true' do
+      check_parsing2('and(true, true)', true)
+    end
+
+    it 'checks and(true,false) == false' do
+      check_parsing2('and(true, false)', false)
+    end
+
+    it 'checks and(false,true) == false' do
+      check_parsing2('and(false, true)', false)
+    end
+
+    it 'checks and(false,false) == false' do
+      check_parsing2('and(false, false)', false)
+    end
+  end
+
+  context 'or function' do
+    it 'checks or(true, true) == true' do
+      check_parsing2('or(true, true)', true)
+    end
+
+    it 'checks or(true, false) == true' do
+      check_parsing2('or(true, false)', true)
+    end
+
+    it 'checks or(false, true) == true' do
+      check_parsing2('or(false, true)', true)
+    end
+
+    it 'checks or(false, false) == false' do
+      check_parsing2('or(false, false)', false)
+    end
+  end
+
+  context 'not function' do
+    it 'checks not(false) == true' do
+      check_parsing2('not(false)', true)
+    end
+
+    it 'checks not(true) == false' do
+      check_parsing2('not(true)', false)
+    end
+
+    it 'checks not(undefined) == false' do
+      check_parsing2('not(undefined)', true)
+    end
+  end
+
+  context 'eq function' do
+    it 'checks eq("la la", "la la")) == true' do
+      check_parsing2('eq("la la", "la la")', true);
+    end
+
+    it 'checks eq("la la", "la,la")) == false' do
+      check_parsing2('eq("la la", "la,la")', false);
+    end
+
+    it 'checks eq("lala", "lala") == true' do
+      check_parsing2('eq("lala", "lala")', true)
+    end
+
+    it 'checks eq(undefined, undefined) == true' do
+      check_parsing2('eq(undefined, undefined)', true)
+    end
+  end
+
+  context 'lt function' do
+    it 'checks lt(500,100) == false' do
+      check_parsing2('lt(500, 100)', false)
+    end
+
+    it 'checks lt(500,500) == false' do
+      check_parsing2('lt(500, 500)', false)
+    end
+
+    it 'checks lt(500,500.54) == true' do
+      check_parsing2('lt(500, 500.54)', true)
+    end
+  end
+
+  context 'lte function' do
+    it 'checks lte(500, 500) == true' do
+      check_parsing2('lte(500, 500)', true)
+    end
+  end
+
+  context 'gt function' do
+    it 'checks gt(500, 100) == true' do
+      check_parsing2('gt(500,100)',true)
+    end
+
+    it 'checks gt(500, 500) == false' do
+      check_parsing2('gt(500,500)',false)
+    end
+
+    it 'checks gt(500.54, 500) == true' do
+      check_parsing2('gt(500.54,500)',true)
+    end
+  end
+
+  context 'gte function' do
+    it 'checks gte(500, 500) == true' do
+      check_parsing2('gte(500,500)',true)
+    end
+
+    it 'checks gte("500", 500) == false' do
+      check_parsing2('gte("500",500)',false)
+    end
+  end
+
+  context 'isUndefined function' do
+    it 'checks isUndefined(undefined) == true' do
+      check_parsing2('isUndefined(undefined)', true)
+    end
+
+    it 'checks isUndefined("undefined") == false' do
+      check_parsing2('isUndefined("undefined")', false)
+    end
+
+    it 'checks isUndefined(123123) == false' do
+      check_parsing2('isUndefined(123123)', false)
+    end
+  end
+
+  context 'now() function' do
+    it 'checks gte(now(), now()) == true' do
+      check_parsing2('gte(now(), now())', true)
+    end
+
+    it 'checks gte(now(), 2458.123) == true' do
+      check_parsing2('gte(now(), 2458.123)', true)
+    end
+  end
+
+  context 'complex checks' do
+    it 'checks and(true, or(true, true)) == true' do
+      check_parsing2('and(true, or(true, true))', true);
+    end
+
+    it 'checks and(true, or(false, true)) == true' do
+      check_parsing2('and(true, or(false, true))', true);
+    end
+
+    it 'checks and(true, or(false, false)) == false' do
+      check_parsing2('and(true, or(false, false))', false);
+    end
+
+    it 'checks not(and(false, or(false, true))) == true' do
+      check_parsing2('not(and(false, or(false, true)))', true);
+    end
+
+    it 'checks ne(100.123, 100.321) == true' do
+      check_parsing2('ne(100.123, 100.321)', true)
+    end
+
+    it 'checks not(eq(undefined, undefined)) == false' do
+      check_parsing('not(eq(undefined, undefined))', 'false')
+    end
+
+    it 'checks not(eq(not(undefined), not(undefined))) == true' do
+      check_parsing2('not(eq(not(undefined), not(undefined)))', true )
+    end
+
+  end
+
+  context 'error checking' do
+    it 'checks NOT_AN_OPERATOR(500, 500) == false' do
+      check_parsing('NOT_AN_OPERATOR(500,500)', 'false')
+    end
+
+    it 'checks JUSTAWORD(500, 500) == false' do
+      check_parsing('JUSTAWORD(500,500)', 'false')
+    end
+  end
+
+#todo check non-matched pairs
+end