dentaku 3.5.0 → 3.5.2

data/spec/ast/abs_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/abs'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Abs' do
+  it 'returns the absolute value of number' do
+    result = Dentaku('ABS(-4.2)')
+    expect(result).to eq(4.2)
+  end
+
+  it 'returns the correct value for positive number' do
+    result = Dentaku('ABS(1.3)')
+    expect(result).to eq(1.3)
+  end
+
+  it 'returns the correct value for zero' do
+    result = Dentaku('ABS(0)')
+    expect(result).to eq(0)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if argument is not numeric' do
+      expect { Dentaku!("ABS(2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/all_spec.rb

@@ -19,7 +19,7 @@ describe Dentaku::AST::All do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
-      Dentaku::ArgumentError, 'ALL() requires second argument to be an identifier'
+      Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/any_spec.rb

@@ -18,6 +18,6 @@ describe Dentaku::AST::Any do
   end
 
   it 'raises argument error if a string is passed as identifier' do
-    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ArgumentError)
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ParseError)
   end
 end

data/spec/ast/arithmetic_spec.rb

@@ -4,12 +4,12 @@ require 'dentaku/ast/arithmetic'
 require 'dentaku/token'
 
 describe Dentaku::AST::Arithmetic do
-  let(:one)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
-  let(:two)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
-  let(:x)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
-  let(:y)    { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
+  let(:one)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 1)) }
+  let(:two)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 2)) }
+  let(:x)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'x')) }
+  let(:y)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'y')) }
   let(:ctx)  { {'x' => 1, 'y' => 2} }
-  let(:date) { Dentaku::AST::DateTime.new Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16)) }
+  let(:date) { Dentaku::AST::DateTime.new(Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16))) }
 
   it 'performs an arithmetic operation with numeric operands' do
     expect(add(one, two)).to eq(3)
@@ -45,6 +45,21 @@ describe Dentaku::AST::Arithmetic do
     expect(add(x, one, 'x' => '.1')).to eq(1.1)
     expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+
+    int_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1"))
+    int_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1"))
+    decimal_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1.0"))
+    decimal_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1.0"))
+
+    [int_one, int_neg_one].permutation(2).each do |(left, right)|
+      expect(add(left, right).class).to eq(Integer)
+    end
+
+    [decimal_one, decimal_neg_one].each do |left|
+      [int_one, int_neg_one, decimal_one, decimal_neg_one].each do |right|
+        expect(add(left, right).class).to eq(BigDecimal)
+      end
+    end
   end
 
   it 'performs arithmetic on arrays' do

data/spec/ast/avg_spec.rb

@@ -3,6 +3,11 @@ require 'dentaku/ast/functions/avg'
 require 'dentaku'
 
 describe 'Dentaku::AST::Function::Avg' do
+  it 'returns the average of an array of Numeric values as BigDecimal' do
+    result = Dentaku('AVG(1, 2)')
+    expect(result).to eq(1.5)
+  end
+
   it 'returns the average of an array of Numeric values' do
     result = Dentaku('AVG(1, x, 1.8)', x: 2.3)
     expect(result).to eq(1.7)

data/spec/ast/comparator_spec.rb

@@ -5,7 +5,9 @@ require 'dentaku/token'
 
 describe Dentaku::AST::Comparator do
   let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:one_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '1') }
   let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:two_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '2') }
   let(:x) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
   let(:y) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
   let(:nilly) do
@@ -21,6 +23,12 @@ describe Dentaku::AST::Comparator do
     expect(equal(x, y).value(ctx)).to be_falsey
   end
 
+  it 'performs conversion from string to numeric operands' do
+    expect(less_than(one, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two).value(ctx)).to be_truthy
+  end
+
   it 'raises a dentaku argument error when incorrect arguments are passed in' do
     expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
     expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError

data/spec/ast/filter_spec.rb

@@ -19,7 +19,7 @@ describe Dentaku::AST::Filter do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('FILTER({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
-      Dentaku::ArgumentError, 'FILTER() requires second argument to be an identifier'
+      Dentaku::ParseError, 'FILTER() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/map_spec.rb

@@ -21,7 +21,7 @@ describe Dentaku::AST::Map do
 
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('MAP({1, 2, 3}, "val", val + 1)') }.to raise_error(
-      Dentaku::ArgumentError,  'MAP() requires second argument to be an identifier'
+      Dentaku::ParseError,  'MAP() requires second argument to be an identifier'
     )
   end
 end

data/spec/ast/or_spec.rb

@@ -6,7 +6,7 @@ describe 'Dentaku::AST::Or' do
   let(:calculator) { Dentaku::Calculator.new }
 
   it 'returns false if all of the arguments are false' do
-    result = Dentaku('OR(1 = "1", 0 = 1)')
+    result = Dentaku('OR(1 = "2", 0 = 1)')
     expect(result).to eq(false)
   end
 

data/spec/ast/pluck_spec.rb

@@ -21,7 +21,7 @@ describe Dentaku::AST::Pluck do
     expect do Dentaku.evaluate!('PLUCK(users, "age")', users: [
       {name: "Bob",  age: 44},
       {name: "Jane", age: 27}
-    ]) end.to raise_error(Dentaku::ArgumentError, 'PLUCK() requires second argument to be an identifier')
+    ]) end.to raise_error(Dentaku::ParseError, 'PLUCK() requires second argument to be an identifier')
   end
 
   it 'raises argument error if a non array of hashes is passed as collection' do

data/spec/bulk_expression_solver_spec.rb

@@ -143,6 +143,15 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       expect(exception.recipient_variable).to eq('more_apples')
     end
 
+    it 'stores the recipient variable on the exception when there is an ArgumentError' do
+      expressions = {apples: "NULL", more_apples: "1 + apples"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      expect(exception.recipient_variable).to eq('more_apples')
+    end
+
     it 'safely handles argument errors' do
       expressions = {i: "a / 5 + d", a: "m * 12", d: "a + b"}
       result = described_class.new(expressions, calculator.store(m: 3)).solve

data/spec/calculator_spec.rb

@@ -22,6 +22,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(2 + 3) - 1')).to eq(4)
     expect(calculator.evaluate('(-2 + 3) - 1')).to eq(0)
     expect(calculator.evaluate('(-2 - 3) - 1')).to eq(-6)
+    expect(calculator.evaluate('1353+91-1-3322-22')).to eq(-1901)
     expect(calculator.evaluate('1 + -(2 ^ 2)')).to eq(-3)
     expect(calculator.evaluate('3 + -num', num: 2)).to eq(1)
     expect(calculator.evaluate('-num + 3', num: 2)).to eq(1)
@@ -40,6 +41,8 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate("2 | 3 * 9")).to eq (27)
     expect(calculator.evaluate("2 & 3 * 9")).to eq (2)
     expect(calculator.evaluate("5%")).to eq (0.05)
+    expect(calculator.evaluate('1 << 3')).to eq (8)
+    expect(calculator.evaluate('0xFF >> 6')).to eq (3)
   end
 
   describe 'evaluate' do
@@ -67,6 +70,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUNDDOWN(a)', a: nil)).to be_nil
       expect(calculator.evaluate('ROUNDUP(a)', a: nil)).to be_nil
       expect(calculator.evaluate('SUM(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('1.0 & "bar"')).to be_nil
     end
 
     it 'treats explicit nil as logical false' do
@@ -82,6 +86,13 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'ast' do
+    it 'raises parsing errors' do
+      expect { calculator.ast('()') }.to raise_error(Dentaku::ParseError)
+      expect { calculator.ast('(}') }.to raise_error(Dentaku::TokenizerError)
+    end
+  end
+
   describe 'evaluate!' do
     it 'raises exception when formula has error' do
       expect { calculator.evaluate!('1 + + 1') }.to raise_error(Dentaku::ParseError)
@@ -108,6 +119,9 @@ describe Dentaku::Calculator do
       expect { calculator.evaluate!('ROUNDDOWN(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('ROUNDUP(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
       expect { calculator.evaluate!('SUM(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('"foo" & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1.0 & "bar"') }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('1 & "bar"') }.to raise_error(Dentaku::ArgumentError)
     end
 
     it 'raises argument error if a function is called with incorrect arity' do
@@ -316,6 +330,11 @@ describe Dentaku::Calculator do
       }.not_to raise_error
     end
 
+    it 'allows to compare "-" or "-."' do
+      expect { calculator.solve("IF('-' =  '-', 0, 1)") }.not_to raise_error
+      expect { calculator.solve("IF('-.'= '-.', 0, 1)") }.not_to raise_error
+    end
+
     it "integrates with custom functions" do
       calculator.add_function(:custom, :integer, -> { 1 })
 
@@ -427,19 +446,42 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_truthy
   end
 
-  it 'supports date arithmetic' do
-    expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 - 2019-12-31')).to eq(1)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
-    expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+  describe 'disabling date literals' do
+    it 'does not parse formulas with minus signs as dates' do
+      calculator = described_class.new(raw_date_literals: false)
+      expect(calculator.evaluate!('2020-01-01')).to eq(2018)
+    end
+  end
+
+  describe 'supports date arithmetic' do
+    it 'from hardcoded string' do
+      expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 - 2019-12-31')).to eq(1)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
+      expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+    end
+
+    it 'from string variable' do
+      value = '2023-01-01'
+
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+    end
+
+    it 'from date object' do
+      value = Date.parse('2023-01-01').to_date
+
+      expect(calculator.evaluate!('value + duration(1, month)', { value: value }).to_date).to eql(Date.parse('2023-02-01'))
+      expect(calculator.evaluate!('value - duration(1, month)', { value: value }).to_date).to eql(Date.parse('2022-12-01'))
+    end
   end
 
   describe 'functions' do
@@ -458,6 +500,13 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
 
+    it 'include ABS' do
+      expect(calculator.evaluate('abs(-2.2)')).to eq(2.2)
+      expect(calculator.evaluate('abs(5)')).to eq(5)
+
+      expect(calculator.evaluate('ABS(x * -1)', x: 10)).to eq(10)
+    end
+
     it 'include NOT' do
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: true)).to be_falsey
       expect(calculator.evaluate('NOT(some_boolean)', some_boolean: false)).to be_truthy
@@ -745,9 +794,9 @@ describe Dentaku::Calculator do
     end
   end
 
-  describe 'math functions' do
+  describe 'math support' do
     Math.methods(false).each do |method|
-      it method do
+      it "includes `#{method}`" do
         if Math.method(method).arity == 2
           expect(calculator.evaluate("#{method}(x,y)", x: 1, y: '2')).to eq(Math.send(method, 1, 2))
           expect(calculator.evaluate("#{method}(x,y) + 1", x: 1, y: '2')).to be_within(0.00001).of(Math.send(method, 1, 2) + 1)
@@ -761,11 +810,16 @@ describe Dentaku::Calculator do
       end
     end
 
-    it 'are defined with a properly named class that represents it to support AST marshaling' do
+    it 'defines a properly named class to support AST marshaling' do
       expect {
         Marshal.dump(calculator.ast('SQRT(20)'))
       }.not_to raise_error
     end
+
+    it 'properly handles a Math::DomainError' do
+      expect(calculator.evaluate('asin(2)')).to be_nil
+      expect { calculator.evaluate!('asin(2)') }.to raise_error(Dentaku::MathDomainError)
+    end
   end
 
   describe 'disable_cache' do

data/spec/external_function_spec.rb

@@ -5,8 +5,7 @@ require 'dentaku/calculator'
 describe Dentaku::Calculator do
   describe 'functions' do
     describe 'external functions' do
-
-      let(:with_external_funcs) do
+      let(:custom_calculator) do
         c = described_class.new
 
         c.add_function(:now, :string, -> { Time.now.to_s })
@@ -22,30 +21,30 @@ describe Dentaku::Calculator do
       end
 
       it 'includes NOW' do
-        now = with_external_funcs.evaluate('NOW()')
+        now = custom_calculator.evaluate('NOW()')
         expect(now).not_to be_nil
         expect(now).not_to be_empty
       end
 
       it 'includes POW' do
-        expect(with_external_funcs.evaluate('POW(2,3)')).to eq(8)
-        expect(with_external_funcs.evaluate('POW(3,2)')).to eq(9)
-        expect(with_external_funcs.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
+        expect(custom_calculator.evaluate('POW(2,3)')).to eq(8)
+        expect(custom_calculator.evaluate('POW(3,2)')).to eq(9)
+        expect(custom_calculator.evaluate('POW(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
       end
 
       it 'includes BIGGEST' do
-        expect(with_external_funcs.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
+        expect(custom_calculator.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
       end
 
       it 'includes SMALLEST' do
-        expect(with_external_funcs.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
+        expect(custom_calculator.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
       end
 
       it 'includes OPTIONAL' do
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2)')).to eq(3)
-        expect(with_external_funcs.evaluate('OPTIONAL(1,2,3)')).to eq(6)
-        expect { with_external_funcs.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
-        expect { with_external_funcs.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2)')).to eq(3)
+        expect(custom_calculator.evaluate('OPTIONAL(1,2,3)')).to eq(6)
+        expect { custom_calculator.dependencies('OPTIONAL()') }.to raise_error(Dentaku::ParseError)
+        expect { custom_calculator.dependencies('OPTIONAL(1,2,3,4)') }.to raise_error(Dentaku::ParseError)
       end
 
       it 'supports array parameters' do
@@ -62,6 +61,66 @@ describe Dentaku::Calculator do
       end
     end
 
+    describe 'with callbacks' do
+      let(:custom_calculator) do
+        c = described_class.new
+
+        @counts = Hash.new(0)
+
+        @initial_time = "2023-02-03"
+        @last_time = @initial_time
+
+        c.add_function(
+            :reverse,
+            :stringl,
+            ->(a) { a.reverse },
+            lambda do |args|
+              args.each do |arg|
+                @counts[arg.value] += 1 if arg.type == :string
+              end
+            end
+        )
+
+        fns = [
+          [:biggest_callback,  :numeric, ->(*args) { args.max }, ->(args) { args.each { |arg| raise Dentaku::ArgumentError unless arg.type == :numeric } }],
+          [:pythagoras, :numeric, ->(l1, l2) { Math.sqrt(l1**2 + l2**2) }, ->(e) { @last_time = Time.now.to_s }],
+          [:callback_lambda, :string, ->() { " " }, ->() { "lambda executed" }],
+          [:no_lambda_function, :numeric, ->(a) { a**a }],
+        ]
+
+        c.add_functions(fns)
+      end
+
+      it 'includes BIGGEST_CALLBACK' do
+        expect(custom_calculator.evaluate('BIGGEST_CALLBACK(1, 2, 5, 4)')).to eq(5)
+        expect { custom_calculator.dependencies('BIGGEST_CALLBACK(1, 3, 6, "hi", 10)') }.to raise_error(Dentaku::ArgumentError)
+      end
+
+      it 'includes REVERSE' do
+        expect(custom_calculator.evaluate('REVERSE(\'Dentaku\')')).to eq('ukatneD')
+        expect { custom_calculator.evaluate('REVERSE(22)') }.to raise_error(NoMethodError)
+        expect(@counts["Dentaku"]).to eq(1)
+      end
+
+      it 'includes PYTHAGORAS' do
+        expect(custom_calculator.evaluate('PYTHAGORAS(8, 7)')).to eq(10.63014581273465)
+        expect(custom_calculator.evaluate('PYTHAGORAS(3, 4)')).to eq(5)
+        expect(@last_time).not_to eq(@initial_time)
+      end
+
+      it 'exposes the `callback` method of a function' do
+        expect(Dentaku::AST::Function::Callback_lambda.callback.call()).to eq("lambda executed")
+      end
+
+      it 'does not add a `callback` method to built-in functions' do
+        expect { Dentaku::AST::If.callback.call }.to raise_error(NoMethodError)
+      end
+
+      it 'defaults `callback` method to nil if not specified' do
+        expect(Dentaku::AST::Function::No_lambda_function.callback).to eq(nil)
+      end
+    end
+
     it 'allows registering "bang" functions' do
       calculator = described_class.new
       calculator.add_function(:hey!, :string, -> { "hey!" })
@@ -82,24 +141,36 @@ describe Dentaku::Calculator do
     end
 
     it 'does not store functions across all calculators' do
-      calculator1 = Dentaku::Calculator.new
+      calculator1 = described_class.new
       calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
 
-      calculator2 = Dentaku::Calculator.new
+      calculator2 = described_class.new
       calculator2.add_function(:my_function, :numeric, ->(x) { 4 * x + 3 })
 
       expect(calculator1.evaluate!("1 + my_function(2)")). to eq(1 + 2 * 2 + 1)
       expect(calculator2.evaluate!("1 + my_function(2)")). to eq(1 + 4 * 2 + 3)
 
       expect {
-        Dentaku::Calculator.new.evaluate!("1 + my_function(2)")
+        described_class.new.evaluate!("1 + my_function(2)")
       }.to raise_error(Dentaku::ParseError)
     end
 
     describe 'Dentaku::Calculator.add_function' do
-      it 'adds to default/global function registry' do
-        Dentaku::Calculator.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
-        expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
+      it 'adds a function to default/global function registry' do
+        described_class.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
+        expect(described_class.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
+      end
+    end
+
+    describe 'Dentaku::Calculator.add_functions' do
+      it 'adds multiple functions to default/global function registry' do
+        described_class.add_functions([
+          [:cube, :numeric, ->(x) { x**3 }],
+          [:spongebob, :string, ->(x) { x.split("").each_with_index().map { |c,i| i.even? ? c.upcase : c.downcase }.join() }],
+        ])
+
+        expect(described_class.new.evaluate("1 + cube(3)")).to eq(28)
+        expect(described_class.new.evaluate("spongebob('How are you today?')")).to eq("HoW ArE YoU ToDaY?")
       end
     end
   end

data/spec/print_visitor_spec.rb

@@ -8,6 +8,12 @@ describe Dentaku::PrintVisitor do
     expect(repr).to eq('5 + 4')
   end
 
+  it 'handles grouping correctly' do
+    formula = '10 - (0 - 10)'
+    repr = roundtrip(formula)
+    expect(repr).to eq(formula)
+  end
+
   it 'quotes string literals' do
     repr = roundtrip('Concat(\'a\',   "B")')
     expect(repr).to eq('CONCAT("a", "B")')

data/spec/tokenizer_spec.rb

@@ -89,6 +89,18 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq([2, :bitand, 3])
   end
 
+  it 'tokenizes bitwise SHIFT LEFT' do
+    tokens = tokenizer.tokenize('2 << 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftleft, 3])
+  end
+
+  it 'tokenizes bitwise SHIFT RIGHT' do
+    tokens = tokenizer.tokenize('2 >> 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftright, 3])
+  end
+
   it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])

data/spec/visitor/infix_spec.rb

@@ -10,6 +10,21 @@ class ArrayProcessor
     @expression = []
   end
 
+  def visit_array(node)
+    @expression << "{"
+
+    head, *tail = node.value
+
+    process(head) if head
+
+    tail.each do |v|
+      @expression << ","
+      process(v)
+    end
+
+    @expression << "}"
+  end
+
   def process(node)
     @expression << node.to_s
   end
@@ -22,10 +37,16 @@ RSpec.describe Dentaku::Visitor::Infix do
     expect(processor.expression).to eq ['5', '+', '3']
   end
 
+  it 'supports array nodes' do
+    processor = ArrayProcessor.new
+    processor.visit(ast('{1, 2, 3}'))
+    expect(processor.expression).to eq ['{', '1', ',', '2', ',', '3', '}']
+  end
+
   private
 
   def ast(expression)
     tokens = Dentaku::Tokenizer.new.tokenize(expression)
     Dentaku::Parser.new(tokens).parse
   end
-end
+end

data/spec/visitor_spec.rb

@@ -90,6 +90,7 @@ describe TestVisitor do
   def generic_subclasses
     [
       :Arithmetic,
+      :Bitwise,
       :Combinator,
       :Comparator,
       :Function,
@@ -111,9 +112,9 @@ describe TestVisitor do
     visit_nodes('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
     visit_nodes('IF(a[0] = NULL, "five", \'seven\')')
     visit_nodes('case (a % 5) when 0 then a else b end')
-    visit_nodes('0xCAFE & 0xDECAF | 0xBEEF')
+    visit_nodes('0xCAFE & (0xDECAF << 3) | (0xBEEF >> 5)')
     visit_nodes('2017-12-24 23:59:59')
-    visit_nodes('ALL({1, 2, 3}, "val", val % 2 == 0)')
+    visit_nodes('ALL({1, 2, 3}, val, val % 2 == 0)')
     visit_nodes('ANY(vals, val, val > 1)')
     visit_nodes('COUNT({1, 2, 3})')
     visit_nodes('PLUCK(users, age)')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.5.2
 platform: ruby
 authors:
 - Solomon White
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-17 00:00:00.000000000 Z
+date: 2023-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -170,6 +170,7 @@ files:
 - lib/dentaku/ast/datetime.rb
 - lib/dentaku/ast/function.rb
 - lib/dentaku/ast/function_registry.rb
+- lib/dentaku/ast/functions/abs.rb
 - lib/dentaku/ast/functions/all.rb
 - lib/dentaku/ast/functions/and.rb
 - lib/dentaku/ast/functions/any.rb
@@ -220,6 +221,7 @@ files:
 - lib/dentaku/tokenizer.rb
 - lib/dentaku/version.rb
 - lib/dentaku/visitor/infix.rb
+- spec/ast/abs_spec.rb
 - spec/ast/addition_spec.rb
 - spec/ast/all_spec.rb
 - spec/ast/and_function_spec.rb
@@ -283,11 +285,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.9
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
+- spec/ast/abs_spec.rb
 - spec/ast/addition_spec.rb
 - spec/ast/all_spec.rb
 - spec/ast/and_function_spec.rb