dentaku 3.0.0 → 3.1.0

data/lib/dentaku/tokenizer.rb

@@ -4,16 +4,21 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
+    attr_reader :case_sensitive, :aliases
+
     LPAREN = TokenMatcher.new(:grouping, :open)
     RPAREN = TokenMatcher.new(:grouping, :close)
 
-    def tokenize(string)
+    def tokenize(string, options = {})
       @nesting = 0
       @tokens  = []
+      @aliases = options.fetch(:aliases, Dentaku.aliases)
       input    = strip_comments(string.to_s.dup)
+      input    = replace_aliases(input)
+      @case_sensitive = options.fetch(:case_sensitive, false)
 
       until input.empty?
-        scanned = TokenScanner.scanners.any? do |scanner|
+        scanned = TokenScanner.scanners(case_sensitive: case_sensitive).any? do |scanner|
           scanned, input = scan(input, scanner)
           scanned
         end
@@ -58,6 +63,25 @@ module Dentaku
       input.gsub(/\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//, '')
     end
 
+    def replace_aliases(string)
+      return string unless @aliases.any?
+
+      string.gsub!(alias_regex) do |match|
+        match_regex = /^#{Regexp.escape(match)}$/i
+
+        @aliases.detect do |(_key, aliases)|
+          !aliases.grep(match_regex).empty?
+        end.first
+      end
+
+      string
+    end
+
+    def alias_regex
+      values = @aliases.values.flatten.join('|')
+      /(?<=\p{Punct}|[[:space:]]|\A)(#{values})(?=\()/i
+    end
+
     private
 
     def fail!(reason, **meta)

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

data/spec/ast/arithmetic_spec.rb

@@ -8,10 +8,10 @@ describe Dentaku::AST::Arithmetic do
   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(:ctx) { {'x' => 1, 'y' => 2} }
 
   it 'performs an arithmetic operation with numeric operands' do
-    expect(add(one, two)).to eq  3
+    expect(add(one, two)).to eq 3
     expect(sub(one, two)).to eq -1
     expect(mul(one, two)).to eq  2
     expect(div(one, two)).to eq  0.5

data/spec/ast/comparator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'dentaku/ast/comparators'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Comparator 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(:ctx) { { 'x' => 'hello', 'y' => 'world' } }
+
+  it 'performs comparison with numeric operands' do
+    expect(less_than(one, two).value(ctx)).to be_truthy
+    expect(less_than(two, one).value(ctx)).to be_falsey
+    expect(greater_than(two, one).value(ctx)).to be_truthy
+    expect(not_equal(x, y).value(ctx)).to be_truthy
+    expect(equal(x, y).value(ctx)).to be_falsey
+  end
+
+  it 'returns correct operator symbols' do
+    expect(less_than(one, two).operator).to eq(:<)
+    expect(less_than_or_equal(one, two).operator).to eq(:<=)
+    expect(greater_than(one, two).operator).to eq(:>)
+    expect(greater_than_or_equal(one, two).operator).to eq(:>=)
+    expect(not_equal(x, y).operator).to eq(:!=)
+    expect(equal(x, y).operator).to eq(:==)
+    expect { Dentaku::AST::Comparator.new(one, two).operator }
+      .to raise_error(NotImplementedError)
+  end
+
+  private
+
+  def less_than(left, right)
+    Dentaku::AST::LessThan.new(left, right)
+  end
+
+  def less_than_or_equal(left, right)
+    Dentaku::AST::LessThanOrEqual.new(left, right)
+  end
+
+  def greater_than(left, right)
+    Dentaku::AST::GreaterThan.new(left, right)
+  end
+
+  def greater_than_or_equal(left, right)
+    Dentaku::AST::GreaterThanOrEqual.new(left, right)
+  end
+
+  def not_equal(left, right)
+    Dentaku::AST::NotEqual.new(left, right)
+  end
+
+  def equal(left, right)
+    Dentaku::AST::Equal.new(left, right)
+  end
+end

data/spec/ast/function_spec.rb

@@ -29,7 +29,7 @@ describe Dentaku::AST::Function do
       one = described_class.register("one", :numeric, ->(x) { x * 2 })
       expect(one.arity).to eq 1
 
-      two = described_class.register("two", :numeric, ->(x,y) { x + y })
+      two = described_class.register("two", :numeric, ->(x, y) { x + y })
       expect(two.arity).to eq 2
 
       many = described_class.register("many", :numeric, ->(*args) { args.max })

data/spec/ast/max_spec.rb

@@ -12,4 +12,9 @@ describe 'Dentaku::AST::Function::Max' do
     result = Dentaku('MAX(1, x, 1.8)', x: '2.3')
     expect(result).to eq 2.3
   end
+
+  it 'returns the largest value even if an Array is passed' do
+    result = Dentaku('MAX(1, x, 1.8)', x: [1.5, 2.3, 1.7])
+    expect(result).to eq 2.3
+  end
 end

data/spec/ast/min_spec.rb

@@ -12,4 +12,9 @@ describe 'Dentaku::AST::Function::Min' do
     result = Dentaku('MIN(1, x, 1.8)', x: '0.3')
     expect(result).to eq 0.3
   end
+
+  it 'returns the smallest value even if an Array is passed' do
+    result = Dentaku('MIN(1, x, 1.8)', x: [1.5, 0.3, 1.7])
+    expect(result).to eq 0.3
+  end
 end

data/spec/ast/sum_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/sum'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Sum' do
+  it 'returns the sum of an array of Numeric values' do
+    result = Dentaku('SUM(1, x, 1.8)', x: 2.3)
+    expect(result).to eq 5.1
+  end
+
+  it 'returns the sum of a single entry array of a Numeric value' do
+    result = Dentaku('SUM(x)', x: 2.3)
+    expect(result).to eq 2.3
+  end
+
+  it 'returns the sum even if a String is passed' do
+    result = Dentaku('SUM(1, x, 1.8)', x: '2.3')
+    expect(result).to eq 5.1
+  end
+
+  it 'returns the sum even if an array is passed' do
+    result = Dentaku('SUM(1, x, 2.3)', x: [4, 5])
+    expect(result).to eq 12.3
+  end
+
+  it 'returns the sum of nested sums' do
+    result = Dentaku('SUM(1, x, SUM(4, 5))', x: '2.3')
+    expect(result).to eq 12.3
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'raises an error if no arguments are passed' do
+      expect { calculator.evaluate!('SUM()') }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/benchmark.rb

@@ -9,12 +9,12 @@ puts "Ruby version #{RUBY_VERSION}"
 
 with_duplicate_variables = [
   "R1+R2+R3+R4+R5+R6",
-  {"R1"=>100000, "R2"=>0, "R3"=>200000, "R4"=>0, "R5"=>500000, "R6"=>0, "r1"=>100000, "r2"=>0, "r3"=>200000, "r4"=>0, "r5"=>500000, "r6"=>0}
+  {"R1" => 100000, "R2" => 0, "R3" => 200000, "R4" => 0, "R5" => 500000, "R6" => 0, "r1" => 100000, "r2" => 0, "r3" => 200000, "r4" => 0, "r5" => 500000, "r6" => 0}
 ]
 
 without_duplicate_variables = [
   "R1+R2+R3+R4+R5+R6",
-  {"R1"=>100000, "R2"=>0, "R3"=>200000, "R4"=>0, "R5"=>500000, "R6"=>0}
+  {"R1" => 100000, "R2" => 0, "R3" => 200000, "R4" => 0, "R5" => 500000, "R6" => 0}
 ]
 
 def test(args, custom_function: true)

data/spec/bulk_expression_solver_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
+require 'dentaku'
 require 'dentaku/bulk_expression_solver'
+require 'dentaku/calculator'
+require 'dentaku/exceptions'
 
 RSpec.describe Dentaku::BulkExpressionSolver do
   let(:calculator) { Dentaku::Calculator.new }
@@ -33,7 +36,46 @@ RSpec.describe Dentaku::BulkExpressionSolver do
     it "does not require keys to be parseable" do
       expressions = { "the value of x, incremented" => "x + 1" }
       solver = described_class.new(expressions, calculator.store("x" => 3))
-      expect(solver.solve!).to eq({ "the value of x, incremented" => 4 })
+      expect(solver.solve!).to eq("the value of x, incremented" => 4)
+    end
+
+    it "evaluates expressions in hashes and arrays, and expands the results" do
+      calculator.store(
+        fruit_quantities: {
+          apple: 5,
+          pear: 9
+        },
+        fruit_prices: {
+          apple: 1.66,
+          pear: 2.50
+        }
+      )
+      expressions = {
+        weekly_budget: {
+          fruit:  "weekly_budget.apples + weekly_budget.pears",
+          apples: "fruit_quantities.apple * discounted_fruit_prices.apple",
+          pears:  "fruit_quantities.pear * discounted_fruit_prices.pear",
+        },
+        discounted_fruit_prices: {
+          apple: "round(fruit_prices.apple * discounts[0], 2)",
+          pear: "round(fruit_prices.pear * discounts[1], 2)"
+        },
+        discounts: ["0.4 * 2", "0.3 * 2"],
+      }
+      solver = described_class.new(expressions, calculator)
+
+      expect(solver.solve!).to eq(
+        weekly_budget: {
+          fruit: 20.15,
+          apples: 6.65,
+          pears: 13.50
+        },
+        discounted_fruit_prices: {
+          apple: 1.33,
+          pear: 1.50
+        },
+        discounts: [0.8, 0.6]
+      )
     end
   end
 
@@ -73,5 +115,51 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       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
+      expect(result).to eq(
+        i: :undefined,
+        d: :undefined,
+        a: 36,
+      )
+    end
+
+    it 'supports nested hashes of expressions using dot notation' do
+      expressions = {
+        a:  "25",
+        b: {
+          c: "a / 5",
+          d: [3, 4, 5]
+        },
+        e: ["b.c + b.d[1]"],
+        f: "e[0] + 1"
+      }
+      results = described_class.new(expressions, calculator).solve
+      expect(results[:f]).to eq 10
+    end
+
+    it 'uses stored values for expressions when they are known' do
+      calculator.store(Force: 50, Mass: 25)
+      expressions = {
+        Force: "Mass * Acceleration",
+        Mass: "Force / Acceleration",
+        Acceleration: "Force / Mass",
+      }
+      solver = described_class.new(expressions, calculator)
+      results = solver.solve
+      expect(results).to eq(Force: 50, Mass: 25, Acceleration: 2)
+    end
+
+    it 'solves all array expressions for which context exists, returning :undefined for the rest' do
+      calculator.store(first: 1, equation: 3)
+      system = {'key' => ['first * equation', 'second * equation'] }
+      solver = described_class.new(system, calculator)
+      expect(solver.dependencies).to eq('key' => ['second'])
+      results = solver.solve
+      expect(results).to eq('key' => [3, :undefined])
+      expect { solver.solve! }.to raise_error(Dentaku::UnboundVariableError)
+    end
   end
 end

data/spec/calculator_spec.rb

@@ -2,8 +2,10 @@ require 'spec_helper'
 require 'dentaku'
 
 describe Dentaku::Calculator do
-  let(:calculator)  { described_class.new }
-  let(:with_memory) { described_class.new.store(apples: 3) }
+  let(:calculator)   { described_class.new }
+  let(:with_memory)  { described_class.new.store(apples: 3) }
+  let(:with_aliases) { described_class.new(aliases: { round: ['rrround'] }) }
+  let(:without_nested_data) { described_class.new(nested_data_support: false) }
 
   it 'evaluates an expression' do
     expect(calculator.evaluate('7+3')).to eq(10)
@@ -32,6 +34,7 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('0.253/0.253')).to eq(1)
     expect(calculator.evaluate('0.253/d', d: 0.253)).to eq(1)
     expect(calculator.evaluate('10 + x', x: 'abc')).to be_nil
+    expect(calculator.evaluate('x * y', x: '.123', y: '100')).to eq(12.3)
     expect(calculator.evaluate('a/b', a: '10', b: '2')).to eq(5)
     expect(calculator.evaluate('t + 1*24*60*60', t: Time.local(2017, 1, 1))).to eq(Time.local(2017, 1, 2))
     expect(calculator.evaluate("2 | 3 * 9")).to eq (27)
@@ -65,17 +68,21 @@ describe Dentaku::Calculator do
     end
 
     it 'stores nested hashes' do
-      calculator.store({a: {basket: {of: 'apples'}}, b: 2})
+      calculator.store(a: {basket: {of: 'apples'}}, b: 2)
       expect(calculator.evaluate!('a.basket.of')).to eq 'apples'
       expect(calculator.evaluate!('b')).to eq 2
     end
 
     it 'stores arrays' do
-      calculator.store({a: [1, 2, 3]})
+      calculator.store(a: [1, 2, 3])
       expect(calculator.evaluate!('a[0]')).to eq 1
       expect(calculator.evaluate!('a[x]', x: 1)).to eq 2
       expect(calculator.evaluate!('a[x+1]', x: 1)).to eq 3
     end
+
+    it 'evalutates arrays' do
+      expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
+    end
   end
 
   describe 'dependencies' do
@@ -92,6 +99,10 @@ describe Dentaku::Calculator do
     it "doesn't consider variables in memory as dependencies" do
       expect(with_memory.dependencies("apples + oranges")).to eq(['oranges'])
     end
+
+    it "finds no dependencies in array literals" do
+      expect(calculator.dependencies([1, 2, 3])).to eq([])
+    end
   end
 
   describe 'solve!' do
@@ -286,7 +297,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('round(8.8)')).to eq(9)
       expect(calculator.evaluate('round(8.75, 1)')).to eq(BigDecimal.new('8.8'))
 
-      expect(calculator.evaluate('ROUND(apples * 0.93)', { apples: 10 })).to eq(9)
+      expect(calculator.evaluate('ROUND(apples * 0.93)', apples: 10)).to eq(9)
     end
 
     it 'include NOT' do
@@ -483,11 +494,11 @@ describe Dentaku::Calculator do
     end
 
     it 'disables the AST cache' do
-      expect(calculator.disable_cache{ |c| c.cache_ast? }).to be false
+      expect(calculator.disable_cache { |c| c.cache_ast? }).to be false
     end
 
     it 'calculates normally' do
-      expect(calculator.disable_cache{ |c| c.evaluate("2 + 2") }).to eq(4)
+      expect(calculator.disable_cache { |c| c.evaluate("2 + 2") }).to eq(4)
     end
   end
 
@@ -539,4 +550,26 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate("max(1, two())")).to eq 2
     end
   end
+
+  describe 'aliases' do
+    it 'accepts aliases as instance option' do
+      expect(with_aliases.evaluate('rrround(5.1)')).to eq 5
+    end
+  end
+
+  describe 'nested_data' do
+    it 'default to nested data enabled' do
+      expect(calculator.nested_data_support).to be_truthy
+    end
+
+    it 'allow opt out of nested data support' do
+      expect(without_nested_data.nested_data_support).to be_falsy
+    end
+
+    it 'should allow optout of nested hash' do
+      expect do
+        without_nested_data.solve!('a.b.c')
+      end.to raise_error(Dentaku::UnboundVariableError)
+    end
+  end
 end

data/spec/dentaku_spec.rb

@@ -25,4 +25,15 @@ describe Dentaku do
       Dentaku('true AND')
     }.to raise_error(Dentaku::ParseError)
   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)
+  end
+
+  it 'evaluates with class-level aliases' do
+    Dentaku.aliases = { roundup: ['roundupup'] }
+    expect(Dentaku.evaluate('roundupup(6.1)')).to eq(7)
+  end
 end

data/spec/external_function_spec.rb

@@ -11,7 +11,7 @@ describe Dentaku::Calculator do
         c.add_function(:now, :string, -> { Time.now.to_s })
 
         fns = [
-          [:pow,      :numeric, ->(mantissa, exponent) { mantissa ** exponent }],
+          [:pow,      :numeric, ->(mantissa, exponent) { mantissa**exponent }],
           [:biggest,  :numeric, ->(*args) { args.max }],
           [:smallest, :numeric, ->(*args) { args.min }],
         ]
@@ -49,7 +49,7 @@ describe Dentaku::Calculator do
           }
         )
 
-        expect(calculator.evaluate("INCLUDES(list, 2)", list: [1,2,3])).to eq(true)
+        expect(calculator.evaluate("INCLUDES(list, 2)", list: [1, 2, 3])).to eq(true)
       end
     end
 
@@ -61,15 +61,15 @@ describe Dentaku::Calculator do
 
     it 'does not store functions across all calculators' do
       calculator1 = Dentaku::Calculator.new
-      calculator1.add_function(:my_function, :numeric, ->(x) { 2*x + 1 })
+      calculator1.add_function(:my_function, :numeric, ->(x) { 2 * x + 1 })
 
       calculator2 = Dentaku::Calculator.new
-      calculator2.add_function(:my_function, :numeric, ->(x) { 4*x + 3 })
+      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)
+      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