dentaku 3.3.0 → 3.4.0

data/spec/dentaku_spec.rb

@@ -27,13 +27,26 @@ describe Dentaku do
   end
 
   it 'evaluates with class-level shortcut functions' do
-    expect(Dentaku.evaluate('2+2')).to eq(4)
-    expect(Dentaku.evaluate!('2+2')).to eq(4)
-    expect { Dentaku.evaluate!('a+1') }.to raise_error(Dentaku::UnboundVariableError)
+    expect(described_class.evaluate('2+2')).to eq(4)
+    expect(described_class.evaluate!('2+2')).to eq(4)
+    expect { described_class.evaluate!('a+1') }.to raise_error(Dentaku::UnboundVariableError)
+  end
+
+  it 'accepts a block for custom handling of unbound variables' do
+    unbound = 'apples * 1.5'
+    expect(described_class.evaluate(unbound) { :bar }).to eq(:bar)
+    expect(described_class.evaluate(unbound) { |e| e }).to eq(unbound)
   end
 
   it 'evaluates with class-level aliases' do
-    Dentaku.aliases = { roundup: ['roundupup'] }
-    expect(Dentaku.evaluate('roundupup(6.1)')).to eq(7)
+    described_class.aliases = { roundup: ['roundupup'] }
+    expect(described_class.evaluate('roundupup(6.1)')).to eq(7)
+  end
+
+  it 'sets caching opt-in flags' do
+    expect {
+      described_class.enable_caching!
+    }.to change { described_class.cache_ast? }.from(false).to(true)
+    .and change { described_class.cache_dependency_order? }.from(false).to(true)
   end
 end

data/spec/external_function_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'dentaku'
 require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
@@ -14,6 +15,7 @@ describe Dentaku::Calculator do
           [:pow,      :numeric, ->(mantissa, exponent) { mantissa**exponent }],
           [:biggest,  :numeric, ->(*args) { args.max }],
           [:smallest, :numeric, ->(*args) { args.min }],
+          [:optional, :numeric, ->(x, y, z = 0) { x + y + z }],
         ]
 
         c.add_functions(fns)
@@ -39,6 +41,13 @@ describe Dentaku::Calculator do
         expect(with_external_funcs.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)
+      end
+
       it 'supports array parameters' do
         calculator = described_class.new
         calculator.add_function(
@@ -59,6 +68,19 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate("hey!()")).to eq("hey!")
     end
 
+    it 'defines for a given function a properly named class that represents it to support AST marshaling' do
+      calculator = described_class.new
+      expect {
+        calculator.add_function(:ho, :string, -> {})
+      }.to change {
+        Dentaku::AST::Function.const_defined?("Ho")
+      }.from(false).to(true)
+
+      expect {
+        Marshal.dump(calculator.ast('MAX(1, 2)'))
+      }.not_to raise_error
+    end
+
     it 'does not store functions across all calculators' do
       calculator1 = Dentaku::Calculator.new
       calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
@@ -66,17 +88,19 @@ describe Dentaku::Calculator do
       calculator2 = Dentaku::Calculator.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(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)")
       }.to raise_error(Dentaku::ParseError)
     end
 
-    it 'self.add_function 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)
+    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)
+      end
     end
   end
 end

data/spec/parser_spec.rb

@@ -1,189 +1,151 @@
 require 'spec_helper'
 require 'dentaku/token'
+require 'dentaku/tokenizer'
 require 'dentaku/parser'
 
 describe Dentaku::Parser do
-  it 'is constructed from a token' do
-    token = Dentaku::Token.new(:numeric, 5)
-    node  = described_class.new([token]).parse
-    expect(node.value).to eq 5
+  it 'parses an integer literal' do
+    node = parse('5')
+    expect(node.value).to eq(5)
   end
 
   it 'performs simple addition' do
-    five = Dentaku::Token.new(:numeric, 5)
-    plus = Dentaku::Token.new(:operator, :add)
-    four = Dentaku::Token.new(:numeric, 4)
-
-    node = described_class.new([five, plus, four]).parse
-    expect(node.value).to eq 9
+    node = parse('5 + 4')
+    expect(node.value).to eq(9)
   end
 
   it 'compares two numbers' do
-    five = Dentaku::Token.new(:numeric, 5)
-    lt   = Dentaku::Token.new(:comparator, :lt)
-    four = Dentaku::Token.new(:numeric, 4)
-
-    node = described_class.new([five, lt, four]).parse
-    expect(node.value).to eq false
+    node = parse('5 < 4')
+    expect(node.value).to eq(false)
   end
 
   it 'calculates unary percentage' do
-    five = Dentaku::Token.new(:numeric, 5)
-    mod  = Dentaku::Token.new(:operator, :mod)
-
-    node = described_class.new([five, mod]).parse
-    expect(node.value).to eq 0.05
+    node = parse('5%')
+    expect(node.value).to eq(0.05)
   end
 
   it 'calculates bitwise OR' do
-    two   = Dentaku::Token.new(:numeric, 2)
-    bitor = Dentaku::Token.new(:operator, :bitor)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([two, bitor, three]).parse
-    expect(node.value).to eq 3
+    node = parse('2|3')
+    expect(node.value).to eq(3)
   end
 
   it 'performs multiple operations in one stream' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    plus  = Dentaku::Token.new(:operator, :add)
-    four  = Dentaku::Token.new(:numeric, 4)
-    times = Dentaku::Token.new(:operator, :multiply)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([five, plus, four, times, three]).parse
-    expect(node.value).to eq 17
+    node = parse('5 * 4 + 3')
+    expect(node.value).to eq(23)
   end
 
   it 'respects order of operations' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    times = Dentaku::Token.new(:operator, :multiply)
-    four  = Dentaku::Token.new(:numeric, 4)
-    plus  = Dentaku::Token.new(:operator, :add)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([five, times, four, plus, three]).parse
-    expect(node.value).to eq 23
+    node = parse('5 + 4*3')
+    expect(node.value).to eq(17)
   end
 
   it 'respects grouping by parenthesis' do
-    lpar  = Dentaku::Token.new(:grouping, :open)
-    five  = Dentaku::Token.new(:numeric, 5)
-    plus  = Dentaku::Token.new(:operator, :add)
-    four  = Dentaku::Token.new(:numeric, 4)
-    rpar  = Dentaku::Token.new(:grouping, :close)
-    times = Dentaku::Token.new(:operator, :multiply)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([lpar, five, plus, four, rpar, times, three]).parse
-    expect(node.value).to eq 27
+    node = parse('(5 + 4) * 3')
+    expect(node.value).to eq(27)
   end
 
   it 'evaluates functions' do
-    fn    = Dentaku::Token.new(:function, :if)
-    fopen = Dentaku::Token.new(:grouping, :open)
-    five  = Dentaku::Token.new(:numeric, 5)
-    lt    = Dentaku::Token.new(:comparator, :lt)
-    four  = Dentaku::Token.new(:numeric, 4)
-    comma = Dentaku::Token.new(:grouping, :comma)
-    three = Dentaku::Token.new(:numeric, 3)
-    two   = Dentaku::Token.new(:numeric, 2)
-    rpar  = Dentaku::Token.new(:grouping, :close)
-
-    node  = described_class.new([fn, fopen, five, lt, four, comma, three, comma, two, rpar]).parse
-    expect(node.value).to eq 2
+    node = parse('IF(5 < 4, 3, 2)')
+    expect(node.value).to eq(2)
   end
 
   it 'represents formulas with variables' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    times = Dentaku::Token.new(:operator, :multiply)
-    x     = Dentaku::Token.new(:identifier, :x)
-
-    node  = described_class.new([five, times, x]).parse
+    node = parse('5 * x')
     expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
-    expect(node.value(x: 3)).to eq 15
+    expect(node.value("x" => 3)).to eq(15)
   end
 
   it 'evaluates access into data structures' do
-    a        = token(:a)
-    lbracket = token(:lbracket)
-    one      = token(1)
-    rbracket = token(:rbracket)
-
-    node = described_class.new([a, lbracket, one, rbracket]).parse
+    node = parse('a[1]')
     expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
-    expect(node.value(a: [1, 2, 3])).to eq 2
+    expect(node.value("a" => [1, 2, 3])).to eq(2)
   end
 
   it 'evaluates boolean expressions' do
-    d_true  = Dentaku::Token.new(:logical, true)
-    d_and   = Dentaku::Token.new(:combinator, :and)
-    d_false = Dentaku::Token.new(:logical, false)
-
-    node = described_class.new([d_true, d_and, d_false]).parse
-    expect(node.value).to eq false
+    node = parse('true AND false')
+    expect(node.value).to eq(false)
   end
 
   it 'evaluates a case statement' do
-    case_start = Dentaku::Token.new(:case, :open)
-    x = Dentaku::Token.new(:identifier, :x)
-    case_when1 = Dentaku::Token.new(:case, :when)
-    one = Dentaku::Token.new(:numeric, 1)
-    case_then1 = Dentaku::Token.new(:case, :then)
-    two = Dentaku::Token.new(:numeric, 2)
-    case_when2 = Dentaku::Token.new(:case, :when)
-    three = Dentaku::Token.new(:numeric, 3)
-    case_then2 = Dentaku::Token.new(:case, :then)
-    four = Dentaku::Token.new(:numeric, 4)
-    case_close = Dentaku::Token.new(:case, :close)
-
-    node = described_class.new(
-      [case_start,
-       x,
-       case_when1,
-       one,
-       case_then1,
-       two,
-       case_when2,
-       three,
-       case_then2,
-       four,
-       case_close]).parse
-    expect(node.value(x: 3)).to eq(4)
+    node = parse('CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 END')
+    expect(node.value("x" => 3)).to eq(4)
+  end
+
+  it 'evaluates arrays' do
+    node = parse('{1, 2, 3}')
+    expect(node.value).to eq([1, 2, 3])
   end
 
   context 'invalid expression' do
     it 'raises a parse error for bad math' do
-      five  = Dentaku::Token.new(:numeric, 5)
-      times = Dentaku::Token.new(:operator, :multiply)
-      minus = Dentaku::Token.new(:operator, :subtract)
-
       expect {
-        described_class.new([five, times, minus]).parse
+        parse("5 * -")
       }.to raise_error(Dentaku::ParseError)
     end
 
     it 'raises a parse error for bad logic' do
-      this = Dentaku::Token.new(:logical, true)
-      also = Dentaku::Token.new(:combinator, :and)
+      expect {
+        parse("TRUE AND")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error for bad grouping structure' do
+      expect {
+        parse(",")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("5, x")
+        described_class.new([five, comma, x]).parse
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("5 + 5, x")
+      }.to raise_error(Dentaku::ParseError)
 
       expect {
-        described_class.new([this, also]).parse
+        parse("{1, 2, }")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CONCAT('1', '2', )")
       }.to raise_error(Dentaku::ParseError)
     end
 
-    it 'raises an exception when trying to access an undefined function' do
-      fn = Dentaku::Token.new(:function, 'non_exists_func')
+    it 'raises parse errors for malformed case statements' do
+      expect {
+        parse("CASE a when 'one' then 1")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("case a whend 'one' then 1 end")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CASE a WHEN 'one' THEND 1 END")
+      }.to raise_error(Dentaku::ParseError)
 
       expect {
-        described_class.new([fn]).parse
+        parse("CASE a when 'one' then end")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error when trying to access an undefined function' do
+      expect {
+        parse("undefined()")
       }.to raise_error(Dentaku::ParseError)
     end
   end
 
-  it "evaluates explicit 'NULL' as a Nil" do
-    null = Dentaku::Token.new(:null, nil)
-    node = described_class.new([null]).parse
+  it "evaluates explicit 'NULL' as nil" do
+    node = parse("NULL")
     expect(node.value).to eq(nil)
   end
+
+  private
+
+  def parse(expr)
+    tokens = Dentaku::Tokenizer.new.tokenize(expr)
+    described_class.new(tokens).parse
+  end
 end

data/spec/spec_helper.rb

@@ -16,9 +16,11 @@ end
 
 RSpec.configure do |c|
   c.before(:all) {
-    # add example for alias because we can set aliases just once
-    # before `calculator` method called
-    Dentaku.aliases = { roundup: ['roundupup'] }
+    if Dentaku.respond_to?(:aliases=)
+      # add example for alias because we can set aliases just once
+      # before `calculator` method called
+      Dentaku.aliases = { roundup: ['roundupup'] }
+    end
   }
 end
 
@@ -45,7 +47,7 @@ def type_for(value)
     :grouping
   when :lbracket, :rbracket
     :access
-  when :le, :ge, :ne, :ne, :lt, :gt, :eq
+  when :le, :ge, :ne, :lt, :gt, :eq
     :comparator
   when :and, :or
     :combinator

data/spec/token_matcher_spec.rb

@@ -82,8 +82,8 @@ describe Dentaku::TokenMatcher do
       it 'matches zero or more occurrences in a token stream' do
         matched, substream = standard.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 1
-        expect(substream.map(&:value)).to eq [5]
+        expect(substream.length).to eq(1)
+        expect(substream.map(&:value)).to eq([5])
 
         matched, substream = standard.match(stream, 4)
         expect(substream).to be_empty
@@ -97,8 +97,8 @@ describe Dentaku::TokenMatcher do
       it 'matches zero or more occurrences in a token stream' do
         matched, substream = star.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 4
-        expect(substream.map(&:value)).to eq [5, 11, 9, 24]
+        expect(substream.length).to eq(4)
+        expect(substream.map(&:value)).to eq([5, 11, 9, 24])
 
         matched, substream = star.match(stream, 4)
         expect(substream).to be_empty
@@ -112,8 +112,8 @@ describe Dentaku::TokenMatcher do
       it 'matches one or more occurrences in a token stream' do
         matched, substream = plus.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 4
-        expect(substream.map(&:value)).to eq [5, 11, 9, 24]
+        expect(substream.length).to eq(4)
+        expect(substream.map(&:value)).to eq([5, 11, 9, 24])
 
         matched, substream = plus.match(stream, 4)
         expect(substream).to be_empty
@@ -126,8 +126,8 @@ describe Dentaku::TokenMatcher do
         stream = token_stream(1, :comma, 2, :comma, true, :comma, 'olive', :comma, :'(')
         matched, substream = described_class.arguments.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 8
-        expect(substream.map(&:value)).to eq [1, :comma, 2, :comma, true, :comma, 'olive', :comma]
+        expect(substream.length).to eq(8)
+        expect(substream.map(&:value)).to eq([1, :comma, 2, :comma, true, :comma, 'olive', :comma])
       end
     end
   end

data/spec/token_scanner_spec.rb

@@ -3,7 +3,7 @@ require 'dentaku/token_scanner'
 describe Dentaku::TokenScanner do
   let(:whitespace) { described_class.new(:whitespace, '\s') }
   let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)',
-    ->(raw) { raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
+    ->(raw) { raw =~ /\./ ? BigDecimal(raw) : raw.to_i })
   }
   let(:custom)     { described_class.new(:identifier, '#\w+\b',
     ->(raw) { raw.gsub('#', '').to_sym })
@@ -29,18 +29,18 @@ describe Dentaku::TokenScanner do
 
   it 'allows customizing available scanners' do
     described_class.scanners = [:whitespace, :numeric]
-    expect(described_class.scanners.length).to eq 2
+    expect(described_class.scanners.length).to eq(2)
   end
 
   it 'ignores invalid scanners' do
     described_class.scanners = [:whitespace, :numeric, :fake]
-    expect(described_class.scanners.length).to eq 2
+    expect(described_class.scanners.length).to eq(2)
   end
 
   it 'uses a custom scanner' do
     described_class.scanners = [:whitespace, :numeric]
     described_class.register_scanner(:custom, custom)
-    expect(described_class.scanners.length).to eq 3
+    expect(described_class.scanners.length).to eq(3)
 
     token = custom.scan('#apple + #pear').first
     expect(token.category).to eq(:identifier)