hayadentaku 3.5.7

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/dependency_resolver_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'dentaku/dependency_resolver'
+
+describe Dentaku::DependencyResolver do
+  it 'sorts expressions in dependency order' do
+    dependencies = {"first" => ["second"], "second" => ["third"], "third" => []}
+    expect(described_class.find_resolve_order(dependencies)).to eq(
+      ["third", "second", "first"]
+    )
+  end
+
+  it 'handles case differences' do
+    dependencies = {"FIRST" => ["second"], "SeCoNd" => ["third"], "THIRD" => []}
+    expect(described_class.find_resolve_order(dependencies)).to eq(
+      ["THIRD", "SeCoNd", "FIRST"]
+    )
+  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,177 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  describe 'functions' do
+    describe 'external functions' do
+      let(:custom_calculator) 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 = custom_calculator.evaluate('NOW()')
+        expect(now).not_to be_nil
+        expect(now).not_to be_empty
+      end
+
+      it 'includes POW' do
+        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(custom_calculator.evaluate('BIGGEST(8,6,7,5,3,0,9)')).to eq(9)
+      end
+
+      it 'includes SMALLEST' do
+        expect(custom_calculator.evaluate('SMALLEST(8,6,7,5,3,0,9)')).to eq(0)
+      end
+
+      it 'includes OPTIONAL' do
+        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
+        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
+
+    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!" })
+      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 = described_class.new
+      calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
+
+      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 {
+        described_class.new.evaluate!("1 + my_function(2)")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    describe 'Dentaku::Calculator.add_function' do
+      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
+end

data/spec/parser_spec.rb

@@ -0,0 +1,183 @@
+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)
+
+    node = parse('(5 | 2) + 1')
+    expect(node.value).to eq(8)
+  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 'parses multiple zero-argument functions in sequence' do
+    node = parse('count() + count()') # count() without arguments returns 0
+    expect(node.value).to eq(0)
+  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('{}')
+    expect(node.value).to eq([])
+
+    node = parse('{1, 2, 3}')
+    expect(node.value).to eq([1, 2, 3])
+
+    node = parse('{1, 2, 3} + {4,5,6}')
+    expect(node.value).to eq([1, 2, 3, 4, 5, 6])
+
+    node = parse('{1, 2, 3} - {2,3}')
+    expect(node.value).to eq([1])
+  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,77 @@
+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 '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")')
+  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
+
+  it 'handles a percentage in a formula' do
+    repr = roundtrip('((3*4%) * 0.001)')
+    expect(repr).to eq('3 * 4% * 0.001')
+  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,69 @@
+require 'pry'
+require 'simplecov'
+
+SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+])
+
+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