dentaku_zevo 3.5.2

data/spec/dentaku_spec.rb

@@ -0,0 +1,52 @@
+require 'dentaku'
+
+describe Dentaku do
+  it 'evaulates an expression' do
+    expect(Dentaku('5+3')).to eql(8)
+  end
+
+  it 'binds values to variables' do
+    expect(Dentaku('oranges > 7', oranges: 10)).to be_truthy
+  end
+
+  it 'evaulates a nested function' do
+    expect(Dentaku('roundup(roundup(3 * cherries) + raspberries)', cherries: 1.5, raspberries: 0.9)).to eql(6)
+  end
+
+  it 'treats variables as case-insensitive' do
+    expect(Dentaku('40 + N', 'n' => 2)).to eql(42)
+    expect(Dentaku('40 + N', 'N' => 2)).to eql(42)
+    expect(Dentaku('40 + n', 'N' => 2)).to eql(42)
+    expect(Dentaku('40 + n', 'n' => 2)).to eql(42)
+  end
+
+  it 'raises a parse error for bad logic expressions' do
+    expect {
+      Dentaku!('true AND')
+    }.to raise_error(Dentaku::ParseError)
+  end
+
+  it 'evaluates with class-level shortcut functions' do
+    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
+    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/exceptions_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'dentaku/exceptions'
+
+describe Dentaku::UnboundVariableError do
+  it 'includes variable name(s) in message' do
+    exception = described_class.new(['length'])
+    expect(exception.unbound_variables).to include('length')
+  end
+end

data/spec/external_function_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  describe 'functions' do
+    describe 'external functions' do
+
+      let(:with_external_funcs) do
+        c = described_class.new
+
+        c.add_function(:now, :string, -> { Time.now.to_s })
+
+        fns = [
+          [: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)
+      end
+
+      it 'includes NOW' do
+        now = with_external_funcs.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)
+      end
+
+      it 'includes BIGGEST' do
+        expect(with_external_funcs.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)
+      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(
+          :includes,
+          :logical,
+          ->(haystack, needle) {
+            haystack.include?(needle)
+          }
+        )
+
+        expect(calculator.evaluate("INCLUDES(list, 2)", list: [1, 2, 3])).to eq(true)
+      end
+    end
+
+    it 'allows registering "bang" functions' do
+      calculator = described_class.new
+      calculator.add_function(:hey!, :string, -> { "hey!" })
+      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 })
+
+      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 {
+        Dentaku::Calculator.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)
+      end
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'dentaku/token'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::Parser do
+  it 'parses an integer literal' do
+    node = parse('5')
+    expect(node.value).to eq(5)
+  end
+
+  it 'performs simple addition' do
+    node = parse('5 + 4')
+    expect(node.value).to eq(9)
+  end
+
+  it 'compares two numbers' do
+    node = parse('5 < 4')
+    expect(node.value).to eq(false)
+  end
+
+  it 'calculates unary percentage' do
+    node = parse('5%')
+    expect(node.value).to eq(0.05)
+  end
+
+  it 'calculates bitwise OR' do
+    node = parse('2|3')
+    expect(node.value).to eq(3)
+  end
+
+  it 'performs multiple operations in one stream' do
+    node = parse('5 * 4 + 3')
+    expect(node.value).to eq(23)
+  end
+
+  it 'respects order of operations' do
+    node = parse('5 + 4*3')
+    expect(node.value).to eq(17)
+  end
+
+  it 'respects grouping by parenthesis' do
+    node = parse('(5 + 4) * 3')
+    expect(node.value).to eq(27)
+  end
+
+  it 'evaluates functions' do
+    node = parse('IF(5 < 4, 3, 2)')
+    expect(node.value).to eq(2)
+  end
+
+  it 'represents formulas with variables' do
+    node = parse('5 * x')
+    expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
+    expect(node.value("x" => 3)).to eq(15)
+  end
+
+  it 'evaluates access into data structures' do
+    node = parse('a[1]')
+    expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
+    expect(node.value("a" => [1, 2, 3])).to eq(2)
+  end
+
+  it 'evaluates boolean expressions' do
+    node = parse('true AND false')
+    expect(node.value).to eq(false)
+  end
+
+  it 'evaluates a case statement' do
+    node = parse('CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 END')
+    expect(node.value("x" => 3)).to eq(4)
+  end
+
+  it 'evaluates a nested case statement with case-sensitivity' do
+    node = parse('CASE x WHEN 1 THEN CASE Y WHEN "A" THEN 2 WHEN "B" THEN 3 END END', { case_sensitive: true }, { case_sensitive: true })
+    expect(node.value("x" => 1, "y" => "A", "Y" => "B")).to eq(3)
+  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
+      expect {
+        parse("5 * -")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error for bad logic' do
+      expect {
+        parse("TRUE AND")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error for too many operands' do
+      expect {
+        parse("IF(1, 0, IF(1, 2, 3, 4))")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CASE a WHEN 1 THEN true ELSE THEN IF(1, 2, 3, 4) END")
+      }.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 {
+        parse("{1, 2, }")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CONCAT('1', '2', )")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    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 {
+        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 nil" do
+    node = parse("NULL")
+    expect(node.value).to eq(nil)
+  end
+
+  private
+
+  def parse(expr, parser_options = {}, tokenizer_options = {})
+    tokens = Dentaku::Tokenizer.new.tokenize(expr, tokenizer_options)
+    described_class.new(tokens, parser_options).parse
+  end
+end

data/spec/print_visitor_spec.rb

@@ -0,0 +1,66 @@
+require 'dentaku/print_visitor'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::PrintVisitor do
+  it 'prints a representation of an AST' do
+    repr = roundtrip('5+4')
+    expect(repr).to eq('5 + 4')
+  end
+
+  it 'quotes string literals' do
+    repr = roundtrip('Concat(\'a\',   "B")')
+    expect(repr).to eq('CONCAT("a", "B")')
+  end
+
+  it 'handles unary operations on literals' do
+    repr = roundtrip('- 4')
+    expect(repr).to eq('-4')
+  end
+
+  it 'handles unary operations on trees' do
+    repr = roundtrip('- (5 + 5)')
+    expect(repr).to eq('-(5 + 5)')
+  end
+
+  it 'handles a complex arithmetic expression' do
+    repr = roundtrip('(((1 + 7) * (8 ^ 2)) / - (3.0 - apples))')
+    expect(repr).to eq('(1 + 7) * 8 ^ 2 / -(3.0 - apples)')
+  end
+
+  it 'handles a complex logical expression' do
+    repr = roundtrip('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
+    expect(repr).to eq('1 < 2 and 3 <= 4 or 5 > 6 and 7 >= 8 or 9 != 10 and true')
+  end
+
+  it 'handles a function call' do
+    repr = roundtrip('IF(a[0] = NULL, "five", \'seven\')')
+    expect(repr).to eq('IF(a[0] = NULL, "five", "seven")')
+  end
+
+  it 'handles a case statement' do
+    repr = roundtrip('case (a % 5) when 0 then a else b end')
+    expect(repr).to eq('CASE a % 5 WHEN 0 THEN a ELSE b END')
+  end
+
+  it 'handles a bitwise operators' do
+    repr = roundtrip('0xCAFE & 0xDECAF | 0xBEEF')
+    expect(repr).to eq('0xCAFE & 0xDECAF | 0xBEEF')
+  end
+
+  it 'handles a datetime literal' do
+    repr = roundtrip('2017-12-24 23:59:59')
+    expect(repr).to eq('2017-12-24 23:59:59')
+  end
+
+  private
+
+  def roundtrip(string)
+    described_class.new(parsed(string)).to_s
+  end
+
+  def parsed(string)
+    tokens = Dentaku::Tokenizer.new.tokenize(string)
+    Dentaku::Parser.new(tokens).parse
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+require 'pry'
+require 'simplecov'
+require 'codecov'
+
+SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::Codecov,
+])
+
+SimpleCov.minimum_coverage 90
+SimpleCov.minimum_coverage_by_file 80
+
+SimpleCov.start do
+  add_filter "spec/"
+end
+
+RSpec.configure do |c|
+  c.before(:all) {
+    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
+
+# automatically create a token stream from bare values
+def token_stream(*args)
+  args.map do |value|
+    type = type_for(value)
+    Dentaku::Token.new(type, value)
+  end
+end
+
+# make a (hopefully intelligent) guess about type
+def type_for(value)
+  case value
+  when Numeric
+    :numeric
+  when String
+    :string
+  when true, false
+    :logical
+  when :add, :subtract, :multiply, :divide, :mod, :pow
+    :operator
+  when :open, :close, :comma
+    :grouping
+  when :lbracket, :rbracket
+    :access
+  when :le, :ge, :ne, :lt, :gt, :eq
+    :comparator
+  when :and, :or
+    :combinator
+  when :if, :round, :roundup, :rounddown, :not
+    :function
+  else
+    :identifier
+  end
+end
+
+def identifier(name)
+  Dentaku::AST::Identifier.new(token(name))
+end
+
+def literal(value)
+  Dentaku::AST::Literal.new(token(value))
+end
+
+def token(value)
+  Dentaku::Token.new(type_for(value), value)
+end

data/spec/token_matcher_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'dentaku/token_matcher'
+
+describe Dentaku::TokenMatcher do
+  it 'with single category matches token category' do
+    matcher = described_class.new(:numeric)
+    token   = Dentaku::Token.new(:numeric, 5)
+
+    expect(matcher).to eq(token)
+  end
+
+  it 'with multiple categories matches any included token category' do
+    matcher    = described_class.new([:comparator, :operator])
+    numeric    = Dentaku::Token.new(:numeric, 5)
+    comparator = Dentaku::Token.new(:comparator, :lt)
+    operator   = Dentaku::Token.new(:operator, :add)
+
+    expect(matcher).to eq(comparator)
+    expect(matcher).to eq(operator)
+    expect(matcher).not_to eq(numeric)
+  end
+
+  it 'with single category and value matches token category and value' do
+    matcher     = described_class.new(:operator, :add)
+    addition    = Dentaku::Token.new(:operator, :add)
+    subtraction = Dentaku::Token.new(:operator, :subtract)
+
+    expect(matcher).to eq(addition)
+    expect(matcher).not_to eq(subtraction)
+  end
+
+  it 'with multiple values matches any included token value' do
+    matcher = described_class.new(:operator, [:add, :subtract])
+    add = Dentaku::Token.new(:operator, :add)
+    sub = Dentaku::Token.new(:operator, :subtract)
+    mul = Dentaku::Token.new(:operator, :multiply)
+    div = Dentaku::Token.new(:operator, :divide)
+
+    expect(matcher).to eq(add)
+    expect(matcher).to eq(sub)
+    expect(matcher).not_to eq(mul)
+    expect(matcher).not_to eq(div)
+  end
+
+  it 'is invertible' do
+    matcher = described_class.new(:operator, [:add, :subtract]).invert
+    add = Dentaku::Token.new(:operator, :add)
+    mul = Dentaku::Token.new(:operator, :multiply)
+    cmp = Dentaku::Token.new(:comparator, :lt)
+
+    expect(matcher).not_to eq(add)
+    expect(matcher).to eq(mul)
+    expect(matcher).to eq(cmp)
+  end
+
+  describe 'combining multiple tokens' do
+    let(:numeric) { described_class.new(:numeric) }
+    let(:string)  { described_class.new(:string) }
+
+    it 'matches either' do
+      either = numeric | string
+      expect(either).to eq(Dentaku::Token.new(:numeric, 5))
+      expect(either).to eq(Dentaku::Token.new(:string, 'rhubarb'))
+    end
+
+    it 'matches any value' do
+      value = described_class.value
+      expect(value).to eq(Dentaku::Token.new(:numeric, 8))
+      expect(value).to eq(Dentaku::Token.new(:string, 'apricot'))
+      expect(value).to eq(Dentaku::Token.new(:logical, false))
+      expect(value).not_to eq(Dentaku::Token.new(:function, :round))
+      expect(value).not_to eq(Dentaku::Token.new(:identifier, :hello))
+    end
+  end
+
+  describe 'stream matching' do
+    let(:stream) { token_stream(5, 11, 9, 24, :hello, 8) }
+
+    describe 'standard' do
+      let(:standard) { described_class.new(:numeric) }
+
+      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])
+
+        matched, substream = standard.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
+      end
+    end
+
+    describe 'star' do
+      let(:star) { described_class.new(:numeric).star }
+
+      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])
+
+        matched, substream = star.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).to be_truthy
+      end
+    end
+
+    describe 'plus' do
+      let(:plus) { described_class.new(:numeric).plus }
+
+      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])
+
+        matched, substream = plus.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
+      end
+    end
+
+    describe 'arguments' do
+      it 'matches comma-separated values' 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])
+      end
+    end
+  end
+end

data/spec/token_scanner_spec.rb

@@ -0,0 +1,49 @@
+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(raw) : raw.to_i })
+  }
+  let(:custom)     { described_class.new(:identifier, '#\w+\b',
+    ->(raw) { raw.gsub('#', '').to_sym })
+  }
+
+  after { described_class.register_default_scanners }
+
+  it 'returns a token for a matching string' do
+    token = whitespace.scan(' ').first
+    expect(token.category).to eq(:whitespace)
+    expect(token.value).to eq(' ')
+  end
+
+  it 'returns falsy for a non-matching string' do
+    expect(whitespace.scan('A')).not_to be
+  end
+
+  it 'performs raw value conversion' do
+    token = numeric.scan('5').first
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
+  end
+
+  it 'allows customizing available scanners' do
+    described_class.scanners = [:whitespace, :numeric]
+    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)
+  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)
+
+    token = custom.scan('#apple + #pear').first
+    expect(token.category).to eq(:identifier)
+    expect(token.value).to eq(:apple)
+  end
+end

data/spec/token_spec.rb

@@ -0,0 +1,16 @@
+require 'dentaku/token'
+
+describe Dentaku::Token do
+  it 'has a category and a value' do
+    token = Dentaku::Token.new(:numeric, 5)
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
+    expect(token.is?(:numeric)).to be_truthy
+  end
+
+  it 'compares category and value to determine equality' do
+    t1 = Dentaku::Token.new(:numeric, 5)
+    t2 = Dentaku::Token.new(:numeric, 5)
+    expect(t1 == t2).to be_truthy
+  end
+end