dentaku 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 402c5a79a4d28d7323c53de8852007fa1c49c087
-  data.tar.gz: e5bd251b569708d740a7aeedde619e3bbfa34037
+SHA256:
+  metadata.gz: bc147a87584da15958dfa99d62dcbc680333b21d2f9a35758ab11b4d7327787b
+  data.tar.gz: a3138608c305adc7ff88168e5379bc5f7da7fa0712b60d9f5d4afb8c63bfa2c3
 SHA512:
-  metadata.gz: a7dda0285c345400228dd7ec606958a95b9f57bd54f87a4333b4533d8f671b9ac66485ec8d29f66360b0dc026b00bb57ca842f4cf07e763c5840a2d84fa5a89e
-  data.tar.gz: d58d8f1451b0092feb6a8038f0d1efe8b6957c5de0a67badf53538395963098912853ea848c5fab03581ffeeddf89e4bb8812a735ec8ba6be48a76db35760e97
+  metadata.gz: 24da7dff044e4909cc1a6f900fb91c1aa30064e940ddf57e1c68112b0d61331b66fa066173012daeb302f757d10ea7ccec1cc505c95d6a8f32c019b2d7d219ff
+  data.tar.gz: 5745ef2e7896a3e0570d236e0b04bdd627659b15da2234855f81adde950c18c3b04d73eaeb34ae836756bfeb37f54bff9886d8730912a32c9e2700161807ac10

data/CHANGELOG.md

@@ -1,6 +1,9 @@
 # Change Log
 
-## [v3.2.0] Unreleased
+## [v3.2.1] 2018-10-24
+- make `evaluate` rescue more exceptions
+
+## [v3.2.0] 2018-03-14
 - add `COUNT` and `AVG` functions
 - add unicode support 😎
 - fix CASE parsing bug
@@ -8,7 +11,7 @@
 - add variadic MUL function
 - performance optimization
 
-## [v3.1.0] 2017-01-10
+## [v3.1.0] 2018-01-10
 - allow decimals with no leading zero
 - nested hash and array support in bulk expression solver
 - add a variadic SUM function
@@ -159,6 +162,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[HEAD]:  https://github.com/rubysolo/dentaku/compare/v3.2.1...HEAD
+[v3.2.1]:  https://github.com/rubysolo/dentaku/compare/v3.2.0...v3.2.1
 [v3.2.0]:  https://github.com/rubysolo/dentaku/compare/v3.1.0...v3.2.0
 [v3.1.0]:  https://github.com/rubysolo/dentaku/compare/v3.0.0...v3.1.0
 [v3.0.0]:  https://github.com/rubysolo/dentaku/compare/v2.0.11...v3.0.0

data/lib/dentaku.rb

@@ -54,3 +54,7 @@ end
 def Dentaku(expression, data = {})
   Dentaku.evaluate(expression, data)
 end
+
+def Dentaku!(expression, data = {})
+  Dentaku.evaluate!(expression, data)
+end

data/lib/dentaku/ast/arithmetic.rb

@@ -159,6 +159,14 @@ module Dentaku
         end
       end
 
+      def dependencies(context = {})
+        if percent?
+          @right.dependencies(context)
+        else
+          super
+        end
+      end
+
       def percent?
         left.nil?
       end

data/lib/dentaku/ast/comparators.rb

@@ -14,11 +14,21 @@ module Dentaku
       def operator
         raise NotImplementedError
       end
+
+      private
+
+      def value
+        yield
+      rescue ::ArgumentError => argument_error
+        raise Dentaku::ArgumentError, argument_error.message
+      rescue NoMethodError => no_method_error
+        raise Dentaku::Error, no_method_error.message
+      end
     end
 
     class LessThan < Comparator
       def value(context = {})
-        left.value(context) < right.value(context)
+        super() { left.value(context) < right.value(context) }
       end
 
       def operator
@@ -28,7 +38,7 @@ module Dentaku
 
     class LessThanOrEqual < Comparator
       def value(context = {})
-        left.value(context) <= right.value(context)
+        super() { left.value(context) <= right.value(context) }
       end
 
       def operator
@@ -38,7 +48,7 @@ module Dentaku
 
     class GreaterThan < Comparator
       def value(context = {})
-        left.value(context) > right.value(context)
+        super() { left.value(context) > right.value(context) }
       end
 
       def operator
@@ -48,7 +58,7 @@ module Dentaku
 
     class GreaterThanOrEqual < Comparator
       def value(context = {})
-        left.value(context) >= right.value(context)
+        super() { left.value(context) >= right.value(context) }
       end
 
       def operator
@@ -58,7 +68,7 @@ module Dentaku
 
     class NotEqual < Comparator
       def value(context = {})
-        left.value(context) != right.value(context)
+        super() { left.value(context) != right.value(context) }
       end
 
       def operator
@@ -68,7 +78,7 @@ module Dentaku
 
     class Equal < Comparator
       def value(context = {})
-        left.value(context) == right.value(context)
+        super() { left.value(context) == right.value(context) }
       end
 
       def operator

data/lib/dentaku/ast/function.rb

@@ -41,7 +41,8 @@ module Dentaku
           return number.include?('.') ? ::BigDecimal.new(number, DIG) : number.to_i if number
         end
 
-        raise TypeError, "#{value || value.class} could not be cast to a number."
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: value, for: Numeric),
+          "'#{value || value.class}' is not coercible to numeric"
       end
     end
   end

data/lib/dentaku/ast/functions/and.rb

@@ -11,9 +11,9 @@ Dentaku::AST::Function.register(:and, :logical, lambda { |*args|
 
   args.all? do |arg|
     case arg
-    when TrueClass, nil
+    when TrueClass
       true
-    when FalseClass
+    when FalseClass, nil
       false
     else
       raise Dentaku::ArgumentError.for(

data/lib/dentaku/ast/functions/or.rb

@@ -11,15 +11,15 @@ Dentaku::AST::Function.register(:or, :logical, lambda { |*args|
 
   args.any? do |arg|
     case arg
-    when TrueClass, nil
+    when TrueClass
       true
-    when FalseClass
+    when FalseClass, nil
       false
     else
       raise Dentaku::ArgumentError.for(
         :incompatible_type,
-        function_name: 'AND()', expect: :logical, actual: arg.class
-      ), 'AND() requires arguments to be logical expressions'
+        function_name: 'OR()', expect: :logical, actual: arg.class
+      ), 'OR() requires arguments to be logical expressions'
     end
   end
 })

data/lib/dentaku/bulk_expression_solver.rb

@@ -20,8 +20,9 @@ module Dentaku
       results = load_results(&error_handler)
 
       FlatHash.expand(
-        expression_hash.each_with_object({}) do |(k, _), r|
-          r[k] = results[k.to_s]
+        expression_hash.each_with_object({}) do |(k, v), r|
+          default = v.nil? ? v : :undefined
+          r[k] = results.fetch(k.to_s, default)
         end
       )
     end
@@ -81,6 +82,9 @@ module Dentaku
           r[var_name] = block.call(ex)
         end
       end
+    rescue TSort::Cyclic => ex
+      block.call(ex)
+      {}
     end
 
     def expressions

data/lib/dentaku/calculator.rb

@@ -46,7 +46,7 @@ module Dentaku
 
     def evaluate(expression, data = {}, &block)
       evaluate!(expression, data)
-    rescue UnboundVariableError, Dentaku::ArgumentError => ex
+    rescue Dentaku::Error, Dentaku::ArgumentError, Dentaku::ZeroDivisionError => ex
       block.call(expression, ex) if block_given?
     end
 

data/lib/dentaku/exceptions.rb

@@ -1,5 +1,8 @@
 module Dentaku
-  class UnboundVariableError < StandardError
+  class Error < StandardError
+  end
+
+  class UnboundVariableError < Error
     attr_accessor :recipient_variable
 
     attr_reader :unbound_variables
@@ -9,7 +12,7 @@ module Dentaku
     end
   end
 
-  class NodeError < StandardError
+  class NodeError < Error
     attr_reader :child, :expect, :actual
 
     def initialize(expect, actual, child)
@@ -19,7 +22,7 @@ module Dentaku
     end
   end
 
-  class ParseError < StandardError
+  class ParseError < Error
     attr_reader :reason, :meta
 
     def initialize(reason, **meta)
@@ -45,7 +48,7 @@ module Dentaku
     end
   end
 
-  class TokenizerError < StandardError
+  class TokenizerError < Error
     attr_reader :reason, :meta
 
     def initialize(reason, **meta)

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.2.0"
+  VERSION = "3.2.1"
 end

data/spec/ast/comparator_spec.rb

@@ -8,7 +8,10 @@ describe Dentaku::AST::Comparator 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' => 'hello', 'y' => 'world' } }
+  let(:nilly) do
+    Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'nilly')
+  end
+  let(:ctx) { { 'x' => 'hello', 'y' => 'world', 'nilly' => nil } }
 
   it 'performs comparison with numeric operands' do
     expect(less_than(one, two).value(ctx)).to be_truthy
@@ -18,6 +21,24 @@ describe Dentaku::AST::Comparator do
     expect(equal(x, y).value(ctx)).to be_falsey
   end
 
+  it 'raises a dentaku argument error when incorrect arguments are passed in' do
+    expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { not_equal(one, nilly).value(ctx) }.to_not raise_error
+    expect { equal(one, nilly).value(ctx) }.to_not raise_error
+  end
+
+  it 'raises a dentaku error when nil is passed in as first argument' do
+    expect { less_than(nilly, one).value(ctx) }.to raise_error Dentaku::Error
+    expect { less_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::Error
+    expect { greater_than(nilly, one).value(ctx) }.to raise_error Dentaku::Error
+    expect { greater_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::Error
+    expect { not_equal(nilly, one).value(ctx) }.to_not raise_error
+    expect { equal(nilly, one).value(ctx) }.to_not raise_error
+  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(:<=)
@@ -29,6 +50,10 @@ describe Dentaku::AST::Comparator do
       .to raise_error(NotImplementedError)
   end
 
+  it 'relies on inheriting classes to expose value method' do
+    expect { described_class.new(one, two).value(ctx) }.to raise_error NoMethodError
+  end
+
   private
 
   def less_than(left, right)

data/spec/ast/function_spec.rb

@@ -54,11 +54,11 @@ describe Dentaku::AST::Function do
   end
 
   it 'raises an error if the value could not be cast to a Numeric' do
-    expect { described_class.numeric('flarble') }.to raise_error TypeError
-    expect { described_class.numeric('-') }.to raise_error TypeError
-    expect { described_class.numeric('') }.to raise_error TypeError
-    expect { described_class.numeric(nil) }.to raise_error TypeError
-    expect { described_class.numeric('7.') }.to raise_error TypeError
-    expect { described_class.numeric(true) }.to raise_error TypeError
+    expect { described_class.numeric('flarble') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('-') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric(nil) }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric('7.') }.to raise_error Dentaku::ArgumentError
+    expect { described_class.numeric(true) }.to raise_error Dentaku::ArgumentError
   end
 end

data/spec/calculator_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'dentaku'
-
 describe Dentaku::Calculator do
   let(:calculator)   { described_class.new }
   let(:with_memory)  { described_class.new.store(apples: 3) }
@@ -39,6 +38,70 @@ describe Dentaku::Calculator do
     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)
     expect(calculator.evaluate("2 & 3 * 9")).to eq (2)
+    expect(calculator.evaluate("5%")).to eq (0.05)
+  end
+
+  describe 'evaluate' do
+    it 'returns nil when formula has error' do
+      expect(calculator.evaluate('1 + + 1')).to be_nil
+    end
+
+    it 'suppresses unbound variable errors' do
+      expect(calculator.evaluate('AND(a,b)')).to be_nil
+      expect(calculator.evaluate('IF(a, 1, 0)')).to be_nil
+      expect(calculator.evaluate('MAX(a,b)')).to be_nil
+      expect(calculator.evaluate('MIN(a,b)')).to be_nil
+      expect(calculator.evaluate('NOT(a)')).to be_nil
+      expect(calculator.evaluate('OR(a,b)')).to be_nil
+      expect(calculator.evaluate('ROUND(a)')).to be_nil
+      expect(calculator.evaluate('ROUNDDOWN(a)')).to be_nil
+      expect(calculator.evaluate('ROUNDUP(a)')).to be_nil
+      expect(calculator.evaluate('SUM(a,b)')).to be_nil
+    end
+
+    it 'suppresses numeric coercion errors' do
+      expect(calculator.evaluate('MAX(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('MIN(a,b)', a: nil, b: nil)).to be_nil
+      expect(calculator.evaluate('ROUND(a)', a: nil)).to be_nil
+      expect(calculator.evaluate('ROUNDDOWN(a)', a: nil)).to be_nil
+      expect(calculator.evaluate('ROUNDUP(a)', a: nil)).to be_nil
+      expect(calculator.evaluate('SUM(a,b)', a: nil, b: nil)).to be_nil
+    end
+
+    it 'treats explicit nil as logical false' do
+      expect(calculator.evaluate('AND(a,b)', a: nil, b: nil)).to be_falsy
+      expect(calculator.evaluate('IF(a,1,0)', a: nil, b: nil)).to eq(0)
+      expect(calculator.evaluate('NOT(a)', a: nil, b: nil)).to be_truthy
+      expect(calculator.evaluate('OR(a,b)', a: nil, b: nil)).to be_falsy
+    end
+  end
+
+  describe 'evaluate!' do
+    it 'raises exception when formula has error' do
+      expect { calculator.evaluate!('1 + + 1') }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises unbound variable errors' do
+      expect { calculator.evaluate!('AND(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('IF(a, 1, 0)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('MAX(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('MIN(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('NOT(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('OR(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUND(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUNDDOWN(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('ROUNDUP(a)') }.to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('SUM(a,b)') }.to raise_error(Dentaku::UnboundVariableError)
+    end
+
+    it 'raises numeric coersion errors' do
+      expect { calculator.evaluate!('MAX(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('MIN(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('ROUND(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('ROUNDDOWN(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('ROUNDUP(a)', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('SUM(a,b)', a: nil, b: nil) }.to raise_error(Dentaku::ArgumentError)
+    end
   end
 
   it 'supports unicode characters in identifiers' do
@@ -84,7 +147,7 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('a[x+1]', x: 1)).to eq 3
     end
 
-    it 'evalutates arrays' do
+    it 'evaluates arrays' do
       expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
     end
   end
@@ -160,6 +223,15 @@ describe Dentaku::Calculator do
 
       expect(result[:weight]).to eq 130.368
     end
+
+    it 'raises an exception if there are cyclic dependencies' do
+      expect {
+        calculator.solve!(
+          make_money: "have_money",
+          have_money: "make_money"
+        )
+      }.to raise_error(TSort::Cyclic)
+    end
   end
 
   describe 'solve' do
@@ -198,6 +270,19 @@ describe Dentaku::Calculator do
         d:           0,
       )
     end
+
+    it 'returns undefined if there are cyclic dependencies' do
+      expect {
+        result = calculator.solve(
+          make_money: "have_money",
+          have_money: "make_money"
+        )
+        expect(result).to eq(
+          make_money: :undefined,
+          have_money: :undefined
+        )
+      }.not_to raise_error
+    end
   end
 
   it 'evaluates a statement with no variables' do

data/spec/dentaku_spec.rb

@@ -22,7 +22,7 @@ describe Dentaku do
 
   it 'raises a parse error for bad logic expressions' do
     expect {
-      Dentaku('true AND')
+      Dentaku!('true AND')
     }.to raise_error(Dentaku::ParseError)
   end
 

data/spec/external_function_spec.rb

@@ -69,7 +69,9 @@ describe Dentaku::Calculator do
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-14 00:00:00.000000000 Z
+date: 2018-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -248,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: dentaku
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A formula language parser and evaluator