hayadentaku 3.5.7

data/spec/ast/string_functions_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/string_functions'
+
+describe Dentaku::AST::StringFunctions::Left do
+  let(:string) { identifier('string') }
+  let(:length) { identifier('length') }
+
+  subject { described_class.new(string, length) }
+
+  it 'returns the left N characters of the string' do
+    expect(subject.value('string' => 'ABCDEFG', 'length' => 4)).to eq 'ABCD'
+  end
+
+  it 'works correctly with literals' do
+    left = literal('ABCD')
+    len  = literal(2)
+    fn   = described_class.new(left, len)
+    expect(fn.value).to eq 'AB'
+  end
+
+  it 'handles an empty string correctly' do
+    expect(subject.value('string' => '', 'length' => 4)).to eq ''
+  end
+
+  it 'handles size greater than input string length correctly' do
+    expect(subject.value('string' => 'abcdefg', 'length' => 40)).to eq 'abcdefg'
+  end
+
+  it 'accepts strings as length if they can be parsed to a number' do
+    expect(subject.value('string' => 'ABCDEFG', 'length' => '4')).to eq 'ABCD'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error if given invalid length' do
+    expect {
+      subject.value('string' => 'abcdefg', 'length' => -2)
+    }.to raise_error(Dentaku::ArgumentError, /LEFT\(\) requires length to be positive/)
+  end
+
+  it 'raises an error when given a junk length' do
+    expect {
+      subject.value('string' => 'abcdefg', 'length' => 'junk')
+    }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Right do
+  it 'returns the right N characters of the string' do
+    subject = described_class.new(literal('ABCDEFG'), literal(4))
+    expect(subject.value).to eq 'DEFG'
+  end
+
+  it 'handles an empty string correctly' do
+    subject = described_class.new(literal(''), literal(4))
+    expect(subject.value).to eq ''
+  end
+
+  it 'handles size greater than input string length correctly' do
+    subject = described_class.new(literal('abcdefg'), literal(40))
+    expect(subject.value).to eq 'abcdefg'
+  end
+
+  it 'accepts strings as length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'))
+    expect(subject.value).to eq 'DEFG'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Mid do
+  it 'returns a substring from the middle of the string' do
+    subject = described_class.new(literal('ABCDEFG'), literal(4), literal(2))
+    expect(subject.value).to eq 'DE'
+  end
+
+  it 'handles an empty string correctly' do
+    subject = described_class.new(literal(''), literal(4), literal(2))
+    expect(subject.value).to eq ''
+  end
+
+  it 'handles offset greater than input string length correctly' do
+    subject = described_class.new(literal('abcdefg'), literal(40), literal(4))
+    expect(subject.value).to eq ''
+  end
+
+  it 'handles size greater than input string length correctly' do
+    subject = described_class.new(literal('abcdefg'), literal(4), literal(40))
+    expect(subject.value).to eq 'defg'
+  end
+
+  it 'accepts strings as offset and length if they can be parsed to a number' do
+    subject = described_class.new(literal('ABCDEFG'), literal('4'), literal('2'))
+    expect(subject.value).to eq 'DE'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+
+  it 'raises an error when given a junk offset' do
+    subject = described_class.new(literal('abcdefg'), literal('junk offset'), literal(2))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk offset' is not coercible to numeric")
+  end
+
+  it 'raises an error when given a junk length' do
+    subject = described_class.new(literal('abcdefg'), literal(4), literal('junk'))
+    expect { subject.value }.to raise_error(Dentaku::ArgumentError, "'junk' is not coercible to numeric")
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Len do
+  it 'returns the length of a string' do
+    subject = described_class.new(literal('ABCDEFG'))
+    expect(subject.value).to eq 7
+  end
+
+  it 'handles an empty string correctly' do
+    subject = described_class.new(literal(''))
+    expect(subject.value).to eq 0
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:numeric)
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Find do
+  it 'returns the position of a substring within a string' do
+    subject = described_class.new(literal('DE'), literal('ABCDEFG'))
+    expect(subject.value).to eq 4
+  end
+
+  it 'handles an empty substring correctly' do
+    subject = described_class.new(literal(''), literal('ABCDEFG'))
+    expect(subject.value).to eq 1
+  end
+
+  it 'handles an empty string correctly' do
+    subject = described_class.new(literal('DE'), literal(''))
+    expect(subject.value).to be_nil
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:numeric)
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Substitute do
+  it 'replaces a substring within a string' do
+    subject = described_class.new(literal('ABCDEFG'), literal('DE'), literal('xy'))
+    expect(subject.value).to eq 'ABCxyFG'
+  end
+
+  it 'handles an empty search string correctly' do
+    subject = described_class.new(literal('ABCDEFG'), literal(''), literal('xy'))
+    expect(subject.value).to eq 'xyABCDEFG'
+  end
+
+  it 'handles an empty replacement string correctly' do
+    subject = described_class.new(literal('ABCDEFG'), literal('DE'), literal(''))
+    expect(subject.value).to eq 'ABCFG'
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Concat do
+  it 'concatenates two strings' do
+    subject = described_class.new(literal('ABC'), literal('DEF'))
+    expect(subject.value).to eq 'ABCDEF'
+  end
+
+  it 'concatenates a string onto an empty string' do
+    subject = described_class.new(literal(''), literal('ABC'))
+    expect(subject.value).to eq 'ABC'
+  end
+
+  it 'concatenates an empty string onto a string' do
+    subject = described_class.new(literal('ABC'), literal(''))
+    expect(subject.value).to eq 'ABC'
+  end
+
+  it 'concatenates two empty strings' do
+    subject = described_class.new(literal(''), literal(''))
+    expect(subject.value).to eq ''
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:string)
+  end
+end
+
+describe Dentaku::AST::StringFunctions::Contains do
+  it 'checks for substrings' do
+    subject = described_class.new(literal('app'), literal('apple'))
+    expect(subject.value).to be_truthy
+    subject = described_class.new(literal('app'), literal('orange'))
+    expect(subject.value).to be_falsy
+  end
+
+  it 'has the proper type' do
+    expect(subject.type).to eq(:logical)
+  end
+end

data/spec/ast/sum_spec.rb

@@ -0,0 +1,43 @@
+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(Dentaku::ArgumentError)
+    end
+
+    it 'does not raise an error if an empty array is passed' do
+      result = calculator.evaluate!('SUM(x)', x: [])
+      expect(result).to eq(0)
+    end
+  end
+end

data/spec/ast/switch_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/switch'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Switch' do
+  it 'returns the match if present in argumtents' do
+    result = Dentaku('SWITCH(1, 1, "one", 2, "two")')
+    expect(result).to eq('one')
+  end
+
+  it 'returns nil if no match was found' do
+    result = Dentaku('SWITCH(3, 1, "one", 2, "two")')
+    expect(result).to eq(nil)
+  end
+
+  it 'returns the default value if present and no match was found' do
+    result = Dentaku('SWITCH(3, 1, "one", 2, "two", "no match")')
+    expect(result).to eq('no match')
+  end
+
+  it 'returns the first match if multiple matches exist' do
+    result = Dentaku('SWITCH(1, 1, "one", 2, "two", 1, "three")')
+    expect(result).to eq('one')
+  end
+
+  it 'does not return a match where a value matches the search value' do
+    result = Dentaku('SWITCH(1, "one", 1, 2, "two", 3)')
+    expect(result).to eq(3)
+  end
+end

data/spec/ast/xor_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/or'
+
+describe 'Dentaku::AST::Xor' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if all of the arguments are false' do
+    result = Dentaku('XOR(false, false)')
+    expect(result).to eq(false)
+  end
+
+  it 'returns true if only one of the arguments is true' do
+    result = Dentaku('XOR(false, true)')
+    expect(result).to eq(true)
+  end
+
+  it 'returns false if more than one of the arguments is true' do
+    result = Dentaku('XOR(false, true, true)')
+    expect(result).to eq(false)
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('XOR(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('XOR()') }.to raise_error(Dentaku::ParseError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('XOR("r")') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/benchmark.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'dentaku'
+require 'allocation_stats'
+require 'benchmark'
+
+puts "Dentaku version #{Dentaku::VERSION}"
+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}
+]
+
+without_duplicate_variables = [
+  "R1+R2+R3+R4+R5+R6",
+  {"R1" => 100000, "R2" => 0, "R3" => 200000, "R4" => 0, "R5" => 500000, "R6" => 0}
+]
+
+def test(args, custom_function: true)
+  calls = [ args ] * 100
+
+  10.times do |i|
+
+    stats = nil
+    bm = Benchmark.measure do
+      stats = AllocationStats.trace do
+
+        calls.each do |formula, bound|
+
+          calculator = Dentaku::Calculator.new
+
+          if custom_function
+            calculator.add_function(
+              :sum,
+              :numeric,
+              ->(numbers) { numbers.inject(:+) }
+            )
+          end
+
+          calculator.evaluate(formula, bound)
+        end
+      end
+    end
+
+    puts "  run #{i}: #{bm.total}"
+    puts stats.allocations(alias_paths: true).group_by(:sourcefile, :class).to_text
+  end
+end
+
+case ARGV[0]
+when '1'
+  puts "with duplicate (downcased) variables, with a custom function:"
+  test(with_duplicate_variables, custom_function: true)
+
+when '2'
+  puts "with duplicate (downcased) variables, without a custom function:"
+  test(with_duplicate_variables, custom_function: false)
+
+when '3'
+  puts "without duplicate (downcased) variables, with a custom function:"
+  test(without_duplicate_variables, custom_function: true)
+
+when '4'
+  puts "with duplicate (downcased) variables, without a custom function:"
+  test(without_duplicate_variables, custom_function: false)
+
+else
+  puts "select a run option (1-4)"
+end

data/spec/bulk_expression_solver_spec.rb

@@ -0,0 +1,241 @@
+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 }
+
+  describe "#solve!" do
+    it "evaluates properly with variables, even if some in memory" do
+      expressions = {
+        weekly_fruit_budget: "weekly_apple_budget + pear * 4",
+        weekly_apple_budget: "apples * 7",
+        pear: "1"
+      }
+      solver = described_class.new(expressions, calculator.store(apples: 3))
+      expect(solver.solve!)
+        .to eq(pear: 1, weekly_apple_budget: 21, weekly_fruit_budget: 25)
+    end
+
+    it "lets you know if a variable is unbound" do
+      expressions = {more_apples: "apples + 1"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
+    it "properly handles access on an unbound variable" do
+      expressions = {more_apples: "apples[0]"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
+    it "lets you know if the result is a div/0 error when dividing" do
+      expressions = {more_apples: "1/0"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::ZeroDivisionError)
+    end
+
+    it "lets you know if the result is a div/0 error when taking modulo" do
+      expressions = {more_apples: "1%0"}
+      expect {
+        described_class.new(expressions, calculator).solve!
+      }.to raise_error(Dentaku::ZeroDivisionError)
+    end
+
+    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)
+    end
+
+    it "allows self-referential formulas" do
+      expressions = { x: "x + 1" }
+      solver = described_class.new(expressions, calculator.store(x: 1))
+      expect(solver.solve!).to eq(x: 2)
+
+      expressions = { x: "y + 3", y: "x * 2" }
+      solver = described_class.new(expressions, calculator.store(x: 5, y: 3))
+      expect(solver.solve!).to eq(x: 6, y: 12) # x = 6 by the time y is calculated
+    end
+
+    it "does not execute functions unnecessarily" do
+      calls = 0
+      external = ->() { calls += 1 }
+      hash = {test: 'EXTERNAL()'}
+      calculator = Dentaku::Calculator.new
+      calculator.add_function(:external, :numeric, external)
+      calculator.solve(hash)
+      expect(calls).to eq(1)
+    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
+
+  describe "#solve" do
+    it 'resolves capitalized keys when they are declared out of order' do
+      expressions = {
+        FIRST: "SECOND * 2",
+        SECOND: "THIRD * 2",
+        THIRD: 2,
+      }
+
+      result = described_class.new(expressions, calculator).solve
+
+      expect(result).to eq(
+        FIRST: 8,
+        SECOND: 4,
+        THIRD: 2
+      )
+    end
+
+    it "returns :undefined when variables are unbound" do
+      expressions = {more_apples: "apples + 1"}
+      expect(described_class.new(expressions, calculator).solve)
+        .to eq(more_apples: :undefined)
+    end
+
+    it "allows passing in a custom value to an error handler when a variable is unbound" do
+      expressions = {more_apples: "apples + 1"}
+      expect(described_class.new(expressions, calculator).solve { :foo })
+        .to eq(more_apples: :foo)
+    end
+
+    it "allows passing in a custom value to an error handler when there is a div/0 error" do
+      expressions = {more_apples: "1/0"}
+      expect(described_class.new(expressions, calculator).solve { :foo })
+        .to eq(more_apples: :foo)
+    end
+
+    it "allows passing in ast as expression" do
+      expressions = {more_apples: calculator.ast("1/0")}
+      expect(described_class.new(expressions, calculator).solve { :foo })
+        .to eq(more_apples: :foo)
+    end
+
+    it 'stores the recipient variable on the exception when there is a div/0 error' do
+      expressions = {more_apples: "1/0"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      expect(exception.recipient_variable).to eq('more_apples')
+    end
+
+    it 'stores the recipient variable on the exception when there is an unbound variable' do
+      expressions = {more_apples: "apples + 1"}
+      exception = nil
+      described_class.new(expressions, calculator).solve do |ex|
+        exception = ex
+      end
+      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
+      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
+
+    it do
+      calculator.store(val: nil)
+      expressions = {
+        a: 'IF(5 / 0 > 0, 100, 1000)',
+        b: 'IF(val = 0, 0, IF(val > 0, 0, 0))'
+      }
+      solver = described_class.new(expressions, calculator)
+      results = solver.solve
+      expect(results).to eq(a: :undefined, b: :undefined)
+    end
+  end
+end