xel 1.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aff030adf152ce449c4cc1680640329458dfc4f53388af9218f3165fbe67e05b
+  data.tar.gz: e654443aeda26b28abad25e9be066132924415cab58b26a31b83e8121e421bc3
+SHA512:
+  metadata.gz: c289c6eedf021d9065d6fd3169c4a8886e4a24765b80c7861a99485eba512fe88afa22de4766422e8cc16fcb36f0a541065d3d7e6bee1264e58b6ce39bea5501
+  data.tar.gz: 7f108af095671d99a9a58b47a35c4c561e61206f554872f85b4282f2aeb6e1147611b3f875235738e87cdb75357bcfb3de153c81a9fe39654f0fa0edddd1ca4e

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+
+# xel.rb
+
+
+## xel.rb 1.5.1  not yet released
+
+* Initial release
+

data/LICENSE.txt

@@ -0,0 +1,26 @@
+
+#
+# Copyright (c) 2015-2024, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+#
+# Made in Japan
+#
+

data/README.md

@@ -0,0 +1,265 @@
+
+# xel.rb
+
+Interpreting expressions built out of a subset of spreadsheet functions.
+
+Twin to [xel.js](https://github.com/jmettraux/xel.js).
+
+```ruby
+require 'xel'
+
+Xel.eval("	= CASE(a<5000000, 0.6, a<10000000, 0.55, 0.45)", { a: 10000 })
+  # --> 0.6
+
+Xel.eval("CASE(a<5000000, 0.6, a<10000000, 0.55, 0.45)", { a: 5_100_000 })
+  # --> 0.55
+```
+
+Here are the eval tests, in the format `code [ ⟶   context] ⟶   result`
+
+```
+987 ⟶   987
+3,000,000 ⟶   3_000_000
+123.45 ⟶   123.45
+9,090.10 ⟶   9_090.1
+.123 ⟶   0.123
+-987 ⟶   -987
+-3,000,000 ⟶   -3_000_000
+-123.45 ⟶   -123.45
+-9,090.10 ⟶   -9_090.10
+-.123 ⟶   -0.123
+
+"12" =~ "[a-z]" ⟶   false
+"a" != "a" ⟶    false
+"a" != "b" ⟶    true
+"a" = "a" ⟶    true
+"a" = "b" ⟶    false
+"a" IN { 0, "a", 2 } ⟶   true
+"a" IN { 0, "b", 2 } ⟶   false
+"a" IN {} ⟶   false
+"ab" =~ "[a-z]" ⟶   true
+
+"b" IN a ⟶   {"a":["a","b","c"]} ⟶   true
+"d" IN a ⟶   {"a":["a","b","c"]} ⟶   false
+
+{ "a" } != { "a" } ⟶   false
+{ "a" } != { "b" } ⟶   true
+{ "a" } = { "a" } ⟶   true
+{ "a" } = { "b" } ⟶   false
+{ "a", "b" } != { "a" } ⟶   true
+{ "a", "b" } != { "a", "b" } ⟶   false
+{ "a", "b" } = { "a" } ⟶   false
+{ "a", "b" } = { "a", "b" } ⟶   true
+{ 1, "a", "b", "c" } ⟶   [ 1, "a", "b", "c" ]
+{ 1, 2 } + { "a", "b" } ⟶   [ 1, 2, "a", "b" ]
+{ { "a", "b" }, { "c", "de" } } ⟶   [ [ "a", "b" ], [ "c", "de" ] ]
+{ { "a", 1 }, { "c", 2 } } ⟶   [ [ "a", 1 ], [ "c", 2 ] ]
+{ "a", "b", "c" } ⟶   [ "a", "b", "c" ]
+{ "a","b" } ⟶   [ "a", "b" ]
+
+LET(price, 100, count, 3, count * price) ⟶   300
+LET(price, 95, count, 3, 12, count * price) ⟶   285
+LET(price, 13, LOWER("COUNT"), 3, count * price) ⟶   39
+LET(l, LAMBDA(a, b, a + b), l(2, 3)) ⟶   5
+LET(_l, LAMBDA(a, b, a * b), _l(2, 3)) ⟶   6
+
+ROUND(3.14159) ⟶   3
+ROUND(3.14159, 0) ⟶   3
+ROUND(3.14159, 2) ⟶   3.14
+ROUND(157, -1) ⟶   160
+ROUND(157, -2) ⟶   200
+ROUND(2.678, 1) ⟶   2.7
+
+MROUND(51, 3) ⟶   51
+MROUND(50, 7) ⟶   49
+MROUND(50, 3) ⟶   51
+MROUND(10, 3) ⟶   9
+MROUND(10, -3) ⟶   nil
+MROUND(-10, 3) ⟶   nil
+MROUND(-10, -3) ⟶   -9
+MROUND(0, 3) ⟶   0
+MROUND(10, 0) ⟶   nil
+MROUND(10.5, 0.3) ⟶   10.5
+MROUND(5, 3) ⟶   6
+MROUND(4, 3) ⟶   3
+MROUND(10.5678, 0.05) ⟶   10.55
+
+  # need MROUND2 for the job, but why again?
+  #
+MROUND2(51, 3) ⟶   51
+MROUND2(50, 7) ⟶   49
+MROUND2(50, 3) ⟶   51
+MROUND2(10, 3) ⟶   9
+MROUND2(10, -3) ⟶   nil
+MROUND2(-10, 3) ⟶   nil
+MROUND2(-10, -3) ⟶   -9
+MROUND2(0, 3) ⟶   0
+MROUND2(10, 0) ⟶   nil
+MROUND2(10.5, 0.3) ⟶   10.5
+MROUND2(5, 3) ⟶   6
+MROUND2(4, 3) ⟶   3
+MROUND2(10.5678, 0.05) ⟶   10.55
+
+CEILING(7, 1) ⟶   7
+CEILING(7) ⟶   7
+CEILING(7.05, 1) ⟶   8
+CEILING(7.05) ⟶   8
+CEILING(7, 5) ⟶   10
+CEILING(49.25, 5) ⟶   50
+CEILING(501, 100) ⟶   600
+CEILING(550, 100) ⟶   600
+CEILING(10.1, 0.25) ⟶   10.25
+
+FLOOR(7, 5) ⟶   5
+FLOOR(49.25) ⟶   49
+FLOOR(49.25, 1) ⟶   49
+FLOOR(550, 100) ⟶   500
+FLOOR(10.1, 0.25) ⟶   10
+
+TRUNC(8.9) ⟶   8
+TRUNC(8.9, 0) ⟶   8
+TRUNC(3.14159, 2) ⟶   3.14
+TRUNC(2.678, 1) ⟶   2.6
+
+"ab\"cd'ef" ⟶   "ab\"cd'ef"
+'ab"cd\'ef' ⟶   "ab\"cd'ef"
+
+0.45 * we_c - 0.15 * it_c + 0.15 * sm_c + 0.25 * gp_c ⟶   \
+  {:we_c=>1.1, :it_c=>2.2, :sm_c=>3.3, :gp_c=>4.4} ⟶   1.76
+
+1 + "a" ⟶   "1a"
+1 + 2 ⟶   3
+1 + a.b.c ⟶   {:a=>{:b=>{:c=>66}}} ⟶   67
+1 + v0 ⟶   {:v0=>70} ⟶   71
+1 - -2 ⟶   3
+1 - 2 ⟶   -1
+1 / 5 ⟶   0.2
+"a" & "bc" ⟶   "abc"
+1 & 1 ⟶   "11"
+"ab" & c & d & "ef" ⟶   {:c=>"c"} ⟶   "abcef"
+1 < 2 ⟶   true
+1 <= 2 ⟶   true
+1 IN a ⟶   {:a=>[0, 1, 2]} ⟶   true
+1 IN { 0, 1 } ⟶   true
+1.0 / 5 ⟶   0.2
+2 != 3 ⟶   true
+2 <= 2 ⟶   true
+2 >= 2 ⟶   true
+3 = 3 ⟶   true
+3 >= 2 ⟶   true
+
+AND(TRUE()) ⟶   true
+AND(TRUE(), TRUE()) ⟶   true
+
+CASE(AND(a > 99, 2 > 1), 2, a > 9, 1, -1) ⟶   {:a=>100} ⟶   2
+CASE(a > 99, 2, a > 9, 1, -1) ⟶   {:a=>100} ⟶   2
+CASE(eb, "&", 10, "g", 11, "a", 12, 13) ⟶   {:eb=>"nada"} ⟶   13
+
+COUNTA(a) ⟶   {:a=>[]} ⟶   0
+COUNTA(a) ⟶   {:a=>[1, 2, 3]} ⟶   3
+
+HAS(a, "b") ⟶   {:a=>["a", "b", "c"]} ⟶   true
+HAS(a, 1) ⟶   {:a=>[0, 1, 2]} ⟶   true
+
+IF(FALSE(), 1, 2) ⟶   2
+IF(TRUE(), 1, 2) ⟶   1
+IF(f, 1, 2) ⟶   {:f=>false} ⟶   2
+IF(t, 1, 2) ⟶   {:t=>true} ⟶   1
+
+INDEX(a, -1) ⟶   {:a=>[0, 1, 2, "trois"]} ⟶   "trois"
+INDEX(a, -2) ⟶   {:a=>[0, 1, 2, "trois"]} ⟶   2
+INDEX(a, 1) ⟶   {:a=>[0, 1, 2]} ⟶   0
+INDEX(a, 2) ⟶   {:a=>[0, 1, 2]} ⟶   1
+INDEX(a, COUNTA(a)) ⟶   {:a=>[0, "two"]} ⟶   "two"
+INDEX({ 'ab', 'cd', 'ef' }, -2) ⟶   "cd"
+
+ISBLANK(a) ⟶   {:a=>""} ⟶   true
+ISBLANK(a) ⟶   {} ⟶   true
+
+ISNUMBER(123) ⟶   true
+ISNUMBER(123.12) ⟶   true
+
+LN(3044.31) ⟶   8.02
+LN(a) ⟶   {:a=>[3044.31, 3047.12]} ⟶   [8.02, 8.02]
+LN({ 3044.31, 3047.12 }) ⟶   [8.02, 8.02]
+
+MATCH("b", a, 0) ⟶   {:a=>["a", "b", "c"]} ⟶   1
+MATCH("d", a, 0) ⟶   {:a=>["a", "b"]} ⟶   -1
+MATCH(1, a, 0) ⟶   {:a=>[0, 1, 2]} ⟶   1
+
+MAX(-1, -2, "a", -3) ⟶   -1
+MAX(-1, -2, -3) ⟶   -1
+MAX(1, 2, 3) ⟶   3
+MIN(-1, -2, "a", -3) ⟶   -1
+MIN(-1, -2, -3) ⟶   -3
+MIN(1, 2, 3) ⟶   1
+NOT(FALSE()) ⟶   true
+
+OR(1 = 2, 2 = 2) ⟶   true
+OR(TRUE(), FALSE()) ⟶   true
+
+PRODUCT(2, 3, 4) ⟶   24
+PRODUCT({ 2, 3, 4 }) ⟶   24
+PRODUCT({ 2, 3, 4 }, 2) ⟶   48
+PRODUCT({ 2, 3, 4 }, a, 2) ⟶   {:a=>[0.5, 0.5]} ⟶   12
+
+PROPER("alpha bravo charly") ⟶   "Alpha Bravo Charly"
+
+SORT({ 1, "aa", 7, 2 }, 1, -1) ⟶   ["aa", 7, 2, 1]
+SORT({ 1, 3, 2 }) ⟶   [1, 2, 3]
+SORT({ 1, 3, 2 }, 1, -1) ⟶   [3, 2, 1]
+
+SQRT(260) ⟶   16.1245
+SQRT(a) ⟶   {:a=>[260, 81]} ⟶   [16.1245, 9]
+SQRT({ 260, 81 }) ⟶   [16.1245, 9]
+
+STDEV(a) ⟶   {:a=>[10, 11]} ⟶   0.71
+
+SUM(2, 3, 4) ⟶   9
+SUM({ 2, 3, 4 }) ⟶   9
+SUM({ 2, 3, 4 }, 2) ⟶   11
+SUM({ 2, 3, 4 }, a, 2) ⟶   {:a=>[0.5, 0.5]} ⟶   12
+
+TRUE() ⟶   true
+
+UNIQUE(a) ⟶   {:a=>[1, 2, 1, 1, 2, 3]} ⟶   [1, 2, 3]
+UNIQUE({ 1, 1 }) ⟶   [1]
+
+UPPER("alpha bravo charly") ⟶   "ALPHA BRAVO CHARLY"
+LOWER("ALPHA BRAVO Charly") ⟶   "alpha bravo charly"
+
+a != "" ⟶   {:a=>"abc"} ⟶   true
+
+LAMBDA(a, b, a + b) ⟶   {}
+
+KALL(LAMBDA(a, b, a + b), 7, -3) ⟶   4
+KALL(LAMBDA(a, b, a + b), 7, -2, 1) ⟶   5
+
+MAP({ 2, 3, 4 }, LAMBDA(a, 2 * a)) ⟶   [4, 6, 8]
+
+REDUCE(0, { 2, 3, 4 }, LAMBDA(a, e, a + e)) ⟶   9
+REDUCE({ 2, 3, 5 }, LAMBDA(a, e, a + e)) ⟶   10
+
+ORV('', '', 1) ⟶   1
+ORV('', b, a, 3) ⟶   {:a=>2} ⟶   2
+
+TEXTJOIN("/", TRUE(), "a", "b") ⟶   "a/b"
+TEXTJOIN(", ", TRUE(), a, "zz") ⟶   {:a=>["ab", "cd", "ef1"]} ⟶   "ab, cd, ef1, zz"
+TEXTJOIN(", ", TRUE(), a, "zz") ⟶   {:a=>["ab", "", "ef1"]} ⟶   "ab, ef1, zz"
+TEXTJOIN(", ", FALSE(), a, "zz") ⟶   {:a=>["ab", "", "ef1"]} ⟶   "ab, , ef1, zz"
+
+D() ⟶   \
+  {}
+D('alpha') ⟶   \
+  { alpha: nil }
+D('alpha', 'bravo') ⟶   \
+  { alpha: 'bravo' }
+D('a', 1, 'b', 'deux', 'charly', { 1, 'deux' }) ⟶   \
+  { a: 1, b: 'deux', charly: [ 1, 'deux' ] }
+```
+
+
+## LICENSE
+
+MIT, see [LICENSE.txt](LICENSE.txt)
+

data/lib/xel/evaluator.rb

@@ -0,0 +1,530 @@
+# frozen_string_literal: true
+
+
+module Xel
+
+  # eval_XXX
+
+  class << self
+
+    protected
+
+    def _eval_args(tree, context, opts={})
+
+      sta = opts[:start] || 1
+      max = opts[:max] || 99
+
+      a = []
+      tree[sta..-1].each do |t|
+        break if a.length >= max
+        a << do_eval(t, context)
+      end
+
+      a
+    end
+
+    def eval_str(tree, context); tree[1]; end
+
+    def eval_num(tree, context)
+
+      s = tree[1].gsub(',', '')
+
+      s.index('.') ? s.to_f : s.to_i
+    end
+
+    def eval_var(tree, context)
+
+      tree[1].split('.')
+        .inject(context) { |r, k|
+          if r && r.respond_to?(:has_key?)
+            ks = k.to_sym
+            if r.has_key?(k)
+              r[k]
+            elsif r.has_key?(ks)
+              r[ks]
+            else
+              nil
+            end
+          else
+            nil
+          end }
+    end
+
+    def eval_inv(tree, context)
+      1.0 / do_eval(tree[1], context)
+    end
+    def eval_opp(tree, context)
+      - do_eval(tree[1], context)
+    end
+
+    def eval_bool(tree, context); tree[0].downcase == 'true'; end
+
+    def do_eval_equal(sign, a0, a1)
+
+      a0 = '' if a0 == nil
+      a1 = '' if a1 == nil
+
+      sign == '=' ? a0 == a1 : a0 != a1
+    end
+
+    def eval_cmp(tree, context)
+
+      args = _eval_args(tree, context, start: 2)
+
+      case tree[1]
+      when '=', '!=' then do_eval_equal(tree[1], args[0], args[1])
+      when '>' then args[0] > args[1]
+      when '<' then args[0] < args[1]
+      when '>=' then args[0] >= args[1]
+      when '<=' then args[0] <= args[1]
+      when '=~' then !! args[0].to_s.match(args[1].to_s)
+      when 'IN' then args[1].include?(args[0])
+      else false
+      end
+
+    rescue
+      false
+    end
+
+    def eval_TRUE(tree, context); tree[0] == 'TRUE'; end
+    alias eval_FALSE eval_TRUE
+
+    alias eval_arr _eval_args
+
+    def eval_plus(tree, context)
+
+      args = _eval_args(tree, context)
+
+      if args[0].is_a?(Array)
+        args.inject([]) { |a, arg| a.concat(arg) }
+      elsif args.find { |a| ! a.is_a?(Numeric) }
+        args.map(&:to_s).join
+      elsif args.all? { |a| a.is_a?(Numeric) }
+        args.inject(&:+)
+      else
+        nil
+      end
+    end
+
+    def eval_amp(tree, context)
+
+      _eval_args(tree, context, start: 1).collect(&:to_s).join
+    end
+
+    def eval_AND(tree, context)
+
+      ! tree[1..-1].find { |c| do_eval(c, context) != true }
+    end
+
+    def eval_OR(tree, context)
+
+      !! tree[1..-1].find { |c| do_eval(c, context) == true }
+    end
+
+    def eval_NOT(tree, context)
+
+      ! do_eval(tree[1], context)
+    end
+
+    def eval_ORV(tree, context)
+
+      tree[1..-1].each do |t|
+        v = do_eval(t, context)
+        return v if v != '' && v!= nil
+      end
+
+      nil
+    end
+
+    def eval_IF(tree, context)
+
+      return do_eval(tree[2], context) if do_eval(tree[1], context)
+      do_eval(tree[3], context)
+    end
+
+    def eval_CASE(tree, context)
+
+      control = do_eval(tree[1], context)
+      args = tree[2..-1]
+
+      if control == true || control == false
+        args.unshift(control)
+        control = true
+      end
+
+      default = args.size.odd? ? args.pop : nil
+
+      while (ab = args.shift(2)).any?
+        return do_eval(ab[1], context) if control == do_eval(ab[0], context)
+      end
+      do_eval(default, context)
+    end
+    alias eval_SWITCH eval_CASE
+
+    def eval_UNIQUE(tree, context)
+
+      arr = do_eval(tree[1], context)
+
+      fail ArgumentError.new("UNIQUE() expects array not #{arr.class}") \
+        unless arr.is_a?(Array)
+
+      arr.uniq
+    end
+
+    # SORT({ 1, 3, 2 })         --> [ 1, 2, 3 ]
+    # SORT({ 1, 3, 2 }, 1, -1)  --> [ 3, 2, 1 ]
+    #
+    def eval_SORT(tree, context)
+
+      #arr, col, dir = _eval_args(tree, context, max: 3)
+      arr, _, dir = _eval_args(tree, context, max: 3)
+
+      fail ArgumentError.new("SORT() expects array not #{arr.class}") \
+        unless arr.is_a?(Array)
+
+      r =
+        arr.all? { |e| e.is_a?(Numeric) } ? arr.sort :
+        arr.sort_by(&:to_s)
+
+      dir == -1 ? r.reverse : r
+    end
+
+    def eval_MUL(tree, context)
+
+      args = _eval_args(tree, context)
+
+      if args.find { |a| ! (a.is_a?(Integer) || a.is_a?(Float)) }
+        fail ArgumentError.new("cannot multiply #{args.inspect}")
+      end
+
+      args.reduce(&:*)
+    end
+
+    def eval_SUM(tree, context)
+
+      f = lambda { |r, e|
+        case e
+        when Numeric then r + e
+        when Array then e.inject(r, &f)
+        else r; end }
+
+      _eval_args(tree, context).inject(0, &f);
+    end
+
+    def eval_PRODUCT(tree, context)
+
+      f = lambda { |r, e|
+        case e
+        when Numeric then r * e
+        when Array then e.inject(r, &f)
+        else r; end }
+
+      _eval_args(tree, context).inject(1, &f)
+    end
+
+    def eval_MIN(tree, context)
+
+      args = _eval_args(tree, context)
+
+      if args.find { |a| ! (a.is_a?(Integer) || a.is_a?(Float)) }
+        args.first
+      else
+        args.min
+      end
+    end
+
+    def eval_MAX(tree, context)
+
+      args = _eval_args(tree, context)
+
+      if args.find { |a| ! (a.is_a?(Integer) || a.is_a?(Float)) }
+        args.first
+      else
+        args.max
+      end
+    end
+
+    def eval_MATCH(tree, context)
+
+      elt = do_eval(tree[1], context)
+      arr = do_eval(tree[2], context)
+
+      return -1 unless arr.is_a?(Array)
+      arr.index(elt) || -1
+    end
+
+    def eval_HAS(tree, context)
+
+      col = do_eval(tree[1], context)
+      elt = do_eval(tree[2], context)
+
+      return !! col.index(elt) if col.is_a?(Array)
+      return col.has_key?(elt) if col.is_a?(Hash)
+      false
+    end
+
+    def eval_INDEX(tree, context)
+
+      col = do_eval(tree[1], context)
+      i = do_eval(tree[2], context)
+
+      return 0 unless col.is_a?(Array)
+      return 0 unless i.is_a?(Numeric)
+
+      i < 0 ?
+        col[i] :
+        col[i.to_i - 1]
+    end
+
+    def eval_COUNTA(tree, context)
+
+      col = do_eval(tree[1], context)
+
+      col.is_a?(Array) ? col.length : 0
+    end
+
+    def eval_ISBLANK(tree, context)
+
+      val = do_eval(tree[1], context)
+
+      val == '' || val == nil
+    end
+
+    def eval_ISNUMBER(tree, context)
+
+      do_eval(tree[1], context).is_a?(Numeric)
+    end
+
+    def eval_PROPER(tree, context)
+      do_eval(tree[1], context).gsub(/(^|[^a-z])([a-z])/) { $1 + $2.upcase }
+    end
+    def eval_LOWER(tree, context)
+      do_eval(tree[1], context).downcase
+    end
+    def eval_UPPER(tree, context)
+      do_eval(tree[1], context).upcase
+    end
+
+    def eval_LN(tree, context)
+      a = do_eval(tree[1], context)
+      return a.map { |e| Math.log(e) } if a.is_a?(Array)
+      Math.log(a)
+    end
+    def eval_SQRT(tree, context)
+      a = do_eval(tree[1], context)
+      return a.map { |e| Math.sqrt(e) } if a.is_a?(Array)
+      Math.sqrt(a)
+    end
+
+    def eval_LET(tree, context)
+
+      ctx = context.dup
+
+      key = nil
+        #
+      tree[1..-2].each_with_index do |t, i|
+        if i % 2 == 0
+          key = (t[0] == 'var') ? t[1] : do_eval(t, ctx).to_s
+        else
+          ctx[key] = do_eval(t, ctx)
+        end
+      end
+
+      do_eval(tree[-1], ctx)
+    end
+
+    def eval_ROUND(tree, context)
+
+      args = _eval_args(tree, context, max: 2)
+      args << 0 if args.length < 2
+
+      args[0].round(args[1])
+    end
+
+    def eval_MROUND(tree, context)
+
+      n, m = _eval_args(tree, context, max: 2)
+
+      return Float::NAN if (n * m) < 0
+
+      (n.to_f / m).round * m rescue nil
+    end
+
+    alias eval_MROUND2 eval_MROUND
+
+    def eval_CEILING(tree, context)
+
+      as = _eval_args(tree, context, max: 2)
+      as << 1 if as.length < 2
+      n, m = as
+      r = n % m
+
+      r == 0 ? n : n - r + m
+    end
+
+    def eval_FLOOR(tree, context)
+
+      as = _eval_args(tree, context, max: 2)
+      as << 1 if as.length < 2
+      n, m = as
+
+      n - (n % m)
+    end
+
+    def eval_TRUNC(tree, context)
+
+      as = _eval_args(tree, context, max: 2)
+      as << 0 if as.length < 2
+      n = as[0]; m = 10 ** as[1]
+
+      (n * m).floor.to_f / m
+    end
+
+    def p2(n); n * n; end
+
+    def eval_STDEV(tree, context)
+
+      a = do_eval(tree[1], context)
+      s = a.inject(0.0) { |acc, e| acc + e }
+      m = s / a.length
+      s = a.inject(0.0) { |acc, e| acc + p2(e - m) }
+      v = s / (a.length - 1)
+
+      Math.sqrt(v)
+    end
+
+    def eval_VLOOKUP(tree, context)
+
+      k, t, i = _eval_args(tree, context, max: 3)
+
+      fail ArgumentError.new(
+        "VLOOKUP() arg 3 #{tree[3].inspect} is not an integer"
+      ) unless i.is_a?(Integer)
+
+      fail ArgumentError.new(
+        "VLOOKUP() arg 2 #{tree[2].inspect} doesn't point to an array of arrays"
+      ) unless t.is_a?(Array)
+
+      t.each_with_index do |r, j|
+
+        fail ArgumentError.new(
+          "VLOOKUP() arg2 row #{j + 1} of table is not an array"
+        ) unless r.is_a?(Array)
+
+        return r[i - 1] if r[0] == k
+      end
+
+      nil
+    end
+
+    def eval_LAMBDA(tree, context)
+
+      args = tree[1..-1].collect { |t| t[1] }
+      code = tree[-1]
+
+      l =
+        Proc.new do |*argl|
+          ctx = context.dup.merge(argl.pop)
+          args.each_with_index { |arg, i| ctx[arg] = argl[i] }
+          Xel.do_eval(code, ctx)
+        end
+      class << l; attr_accessor :_source; end
+      l._source = tree._source
+
+      l
+    end
+
+    def eval_KALL(tree, context)
+
+      args = _eval_args(tree, context)
+      args << context
+
+      fun = args.shift
+
+      fun.call(*args)
+    end
+
+    def eval_MAP(tree, context)
+
+      arr, fun = _eval_args(tree, context, max: 2)
+
+      arr.collect { |e| fun.call(e, context) }
+    end
+
+    def eval_REDUCE(tree, context)
+
+      ts = tree[1..-1]
+      fun = do_eval(ts.pop, context)
+      v0 = do_eval(ts[0], context)
+
+      acc, arr = nil
+        if ts.length == 1
+          arr = v0
+          acc = arr.shift
+        else
+          acc = v0
+          arr = do_eval(ts[1], context)
+        end
+
+      arr.inject(acc) { |r, e| fun.call(r, e, context) }
+    end
+
+    def eval_TEXTJOIN(tree, context)
+
+      agg = lambda { |acc, x|
+        case x
+        when String then acc << x.strip
+        when Array then x.each { |e| agg.call(acc, e) }
+        when nil then acc << ''
+        else acc << x.inspect; end
+        acc }
+
+      del, ign = _eval_args(tree, context, max: 2)
+
+      txs = tree[3..-1].inject([]) { |r, t| agg.call(r, do_eval(t, context)) }
+
+      txs = txs.select { |t| t.length > 0 } if ign
+
+      txs.join(del)
+    end
+
+    def eval_D(tree, context)
+
+      _eval_args(tree, context)
+        .each_slice(2)
+        .inject({}) { |h, (k, v)| h[k] = v; h }
+    end
+
+    def do_eval(tree, context={})
+
+      return tree unless tree.is_a?(Array) && tree.first.class == String
+
+      t0 = tree[0]
+
+      if (v = context[t0]) && v.is_a?(Proc)
+        args = _eval_args(tree, context)
+        args << context
+        return v.call(*args)
+      end
+
+      cfs = context['_custom_functions'] || context[:_custom_functions]
+
+      if (v = cfs && (cfs[t0] || cfs[t0.to_sym])) && v.is_a?(Proc)
+        return v.call(tree, context)
+      end
+
+      send("eval_#{t0}", tree, context)
+    end
+
+    public
+
+    def eval(s, context={})
+
+      t = s.is_a?(Array) ? s : Xel::Parser.parse(s)
+      fail ArgumentError.new("syntax error in >>#{s}<<") unless t
+
+      do_eval(t, context)
+    end
+  end
+end
+

data/lib/xel/parser.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+
+module Xel::Parser include Raabro
+
+  # parse
+
+  def aa(i); rex(nil, i, /\{\s*/); end
+  def az(i); rex(nil, i, /\}\s*/); end
+  def pa(i); rex(nil, i, /\(\s*/); end
+  def pz(i); rex(nil, i, /\)\s*/); end
+  def com(i); rex(nil, i, /,\s*/); end
+
+  def number(i)
+    rex(:number, i, /-?(\.[0-9]+|([0-9][,0-9]*[0-9]|[0-9]+)(\.[0-9]+)?)\s*/)
+  end
+
+  def var(i); rex(:var, i, /[a-z_][A-Za-z0-9_.]*\s*/); end
+
+  def arr(i); eseq(:arr, i, :aa, :cmp, :com, :az); end
+
+  def qstring(i); rex(:qstring, i, /'(\\'|[^'])*'\s*/); end
+  def dqstring(i); rex(:dqstring, i, /"(\\"|[^"])*"\s*/); end
+  def string(i); alt(:string, i, :dqstring, :qstring); end
+
+  def funargs(i); eseq(:funargs, i, :pa, :cmp, :com, :pz); end
+  def funname(i); rex(:funname, i, /[_a-zA-Z][_a-zA-Z0-9]*/); end
+  def fun(i); seq(:fun, i, :funname, :funargs); end
+
+  def comparator(i); rex(:comparator, i, /([\<\>]=?|=~|!?=|IN)\s*/); end
+  def multiplier(i); rex(:multiplier, i, /[*\/]\s*/); end
+  def adder(i); rex(:adder, i, /[+\-&]\s*/); end
+
+  def par(i); seq(:par, i, :pa, :cmp, :pz); end
+  def exp(i); alt(:exp, i, :par, :fun, :number, :string, :arr, :var); end
+
+  def mul(i); jseq(:mul, i, :exp, :multiplier); end
+  def add(i); jseq(:add, i, :mul, :adder); end
+
+  def rcmp(i); seq(:rcmp, i, :comparator, :add); end
+  def cmp(i); seq(:cmp, i, :add, :rcmp, '?'); end
+
+  def prequal(i); rex(nil, i, /\s*=?\s*/); end
+  def root(i); seq(nil, i, :prequal, :cmp); end
+
+  # rewrite
+
+  def rewrite_cmp(tree)
+
+    return rewrite(tree.children.first) if tree.children.size == 1
+
+    [ 'cmp',
+      tree.children[1].children.first.string.strip,
+      rewrite(tree.children[0]),
+      rewrite(tree.children[1].children[1]) ]
+  end
+
+  def rewrite_add(tree)
+
+    return rewrite(tree.children.first) if tree.children.size == 1
+
+    cn = tree.children.dup
+    a = [ tree.name == :add ? 'plus' : 'MUL' ]
+    a = [ 'amp' ] if cn[1] && cn[1].strinp == '&'
+    mod = nil
+
+    while c = cn.shift
+      v = rewrite(c)
+      v = [ mod, v ] if mod
+      a << v
+      c = cn.shift
+      break unless c
+      mod = { '-' => 'opp', '/' => 'inv' }[c.string.strip]
+    end
+
+    a
+  end
+  alias rewrite_mul rewrite_add
+
+  def rewrite_fun(tree)
+
+    t =
+      [ tree.children[0].string ] +
+      tree.children[1].children.select(&:name).collect { |c| rewrite(c) }
+    class << t; attr_accessor :_source; end
+    t._source = tree.strinp
+
+    t
+  end
+
+  def rewrite_exp(tree); rewrite(tree.children[0]); end
+  def rewrite_par(tree); rewrite(tree.children[1]); end
+
+  def rewrite_arr(tree)
+
+    [ 'arr',
+      *tree.children.inject([]) { |a, c| a << rewrite(c) if c.name; a } ]
+  end
+
+  def rewrite_var(tree); [ 'var', tree.string.strip ]; end
+  def rewrite_number(tree); [ 'num', tree.string.strip ]; end
+
+  def rewrite_string(tree)
+
+    s = tree.children[0].string.strip
+    q = s[0]
+    s = s[1..-2]
+
+    [ 'str', q == '"' ? s.gsub("\\\"", '"') : s.gsub("\\'", "'") ]
+  end
+end
+

data/lib/xel.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+
+module Xel
+
+  VERSION = '1.5.1'
+end
+
+require 'raabro'
+
+require 'xel/parser'
+require 'xel/evaluator'
+
+
+module Xel
+
+  class << self
+
+    def parse(s)
+
+      Xel::Parser.parse(s)
+    end
+  end
+end
+

data/xel.gemspec

@@ -0,0 +1,46 @@
+
+Gem::Specification.new do |s|
+
+  s.name = 'xel'
+
+  s.version = File.read(
+    File.expand_path('../lib/xel.rb', __FILE__)
+  ).match(/ VERSION *= *['"]([^'"]+)/)[1]
+
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'John Mettraux' ]
+  s.email = [ 'jmettraux@gmail.com' ]
+  s.homepage = 'https://github.com/jmettraux/xel'
+  s.license = 'MIT'
+  s.summary = 'interprets the expressions usually found in a spreadsheet cell'
+
+  s.description = %{
+Xel interprets the expressions usually found in a spreadsheet cell, hence its diminutive name.
+  }.strip
+
+  s.metadata = {
+    'changelog_uri' => s.homepage + '/blob/master/CHANGELOG.md',
+    'documentation_uri' => s.homepage,
+    'bug_tracker_uri' => s.homepage + '/issues',
+    #'mailing_list_uri' => 'https://groups.google.com/forum/#!forum/floraison',
+    'homepage_uri' =>  s.homepage,
+    'source_code_uri' => s.homepage,
+    #'wiki_uri' => s.homepage + '/wiki',
+  }
+
+  #s.files = `git ls-files`.split("\n")
+  s.files = Dir[
+    'README.{md,txt}',
+    'CHANGELOG.{md,txt}', 'CREDITS.{md,txt}', 'LICENSE.{md,txt}',
+    #'Makefile',
+    'lib/**/*.rb', #'spec/**/*.rb', 'test/**/*.rb',
+    "#{s.name}.gemspec",
+  ]
+
+  s.add_runtime_dependency 'raabro', '~> 1.4'
+
+  s.add_development_dependency 'rspec', '~> 3.8'
+
+  s.require_path = 'lib'
+end
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: xel
+version: !ruby/object:Gem::Version
+  version: 1.5.1
+platform: ruby
+authors:
+- John Mettraux
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: raabro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+description: Xel interprets the expressions usually found in a spreadsheet cell, hence
+  its diminutive name.
+email:
+- jmettraux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/xel.rb
+- lib/xel/evaluator.rb
+- lib/xel/parser.rb
+- xel.gemspec
+homepage: https://github.com/jmettraux/xel
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/jmettraux/xel/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/jmettraux/xel
+  bug_tracker_uri: https://github.com/jmettraux/xel/issues
+  homepage_uri: https://github.com/jmettraux/xel
+  source_code_uri: https://github.com/jmettraux/xel
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: interprets the expressions usually found in a spreadsheet cell
+test_files: []