dentaku 3.3.2 → 3.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1166f2fd23824ca3950d6db37cbd48d0198e939311b69541d37a832ce4106904
-  data.tar.gz: 81452369184a17266465c58797ee4ff4643e7d47ab6762f4b38ac2a23cac6ad0
+  metadata.gz: 3028783062dbbe592ef71ed7bc388e57fb3af383e8cb897893dc858c4b772f63
+  data.tar.gz: c940b16dcfdc9e0d1658a6b38b7521e7a17882c9519a1771d4117600a614100a
 SHA512:
-  metadata.gz: d576e283f2381a8bf270981e1451f0668fd321e34c8a47f868a578411c82d1567402fc8d7dd264feb32fc82c1b722b01a931b439854c826d229e140419cf2d9c
-  data.tar.gz: bf601b8bdd70be48c02b801e05769bd8ce988552458d85512ef3445c39419f98d08e92915e6cc310cb772eb5d9c0b3db51c8dfec3dbe3665aa3533151110fbd8
+  metadata.gz: 7e9633152d5e43e11b52db3a91e8c012816c2cf956e5e3906ce2c058c44d5733fc2668d57049dbc3c44d07155c12bd3bcd8f416e4012986ddcd937bd46cae49c
+  data.tar.gz: bf89bf9096af4720832a7c904ce981a98beb69388996a1d29b190ce279fb8248eddc56175c5cc77646a36c65a0acc78dcd6c98fffb04ad0773cae22630eb3fdd

data/.rubocop.yml

@@ -105,7 +105,7 @@ Layout/TrailingWhitespace:
   Enabled: true
 
 # Use quotes for string literals when they are enough.
-Style/UnneededPercentQ:
+Style/RedundantPercentQ:
   Enabled: true
 
 # Align `end` with the matching keyword or starting expression except for

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## [Unreleased]
+- date / duration addition and subtraction
+- validate arity for custom functions with variable arity
+- make AST serializable with Marshal.dump
+- performance optimization for arithmetic node validation
+- support lazy evaluation for expensive values
+- short-circuit IF function
+- better error when empty string is used in arithmetic operation
+
 ## [v3.3.2] 2019-06-10
 - add ability to pre-load AST cache
 - fix negation node bug
@@ -175,7 +184,7 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
-[HEAD]:  https://github.com/rubysolo/dentaku/compare/v3.3.2...HEAD
+[Unreleased]:  https://github.com/rubysolo/dentaku/compare/v3.3.2...HEAD
 [v3.3.2]:  https://github.com/rubysolo/dentaku/compare/v3.3.1...v3.3.2
 [v3.3.1]:  https://github.com/rubysolo/dentaku/compare/v3.3.0...v3.3.1
 [v3.3.0]:  https://github.com/rubysolo/dentaku/compare/v3.2.1...v3.3.0

data/lib/dentaku/ast.rb

@@ -18,6 +18,7 @@ require_relative './ast/function_registry'
 require_relative './ast/functions/and'
 require_relative './ast/functions/avg'
 require_relative './ast/functions/count'
+require_relative './ast/functions/duration'
 require_relative './ast/functions/if'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'

data/lib/dentaku/ast/access.rb

@@ -5,6 +5,14 @@ module Dentaku
         2
       end
 
+      def self.min_param_count
+        arity
+      end
+
+      def self.max_param_count
+        arity
+      end
+
       def self.peek(*)
       end
 
@@ -22,6 +30,10 @@ module Dentaku
       def dependencies(context = {})
         @structure.dependencies(context) + @index.dependencies(context)
       end
+
+      def type
+        nil
+      end
     end
   end
 end

data/lib/dentaku/ast/arithmetic.rb

@@ -1,4 +1,5 @@
 require_relative './operation'
+require_relative '../date_arithmetic'
 require 'bigdecimal'
 require 'bigdecimal/util'
 
@@ -12,6 +13,7 @@ module Dentaku
           raise NodeError.new(:numeric, left.type, :left),
                 "#{self.class} requires numeric operands"
         end
+
         unless valid_right?
           raise NodeError.new(:numeric, right.type, :right),
                 "#{self.class} requires numeric operands"
@@ -50,15 +52,15 @@ module Dentaku
       end
 
       def valid_node?(node)
-        node && (node.dependencies.any? || node.type == :numeric)
+        node && (node.type == :numeric || node.dependencies.any?)
       end
 
       def valid_left?
-        valid_node?(left)
+        valid_node?(left) || left.type == :datetime
       end
 
       def valid_right?
-        valid_node?(right)
+        valid_node?(right) || right.type == :duration
       end
 
       def validate_value(val)
@@ -77,7 +79,7 @@ module Dentaku
       end
 
       def validate_format(string)
-        unless string =~ /\A-?\d*(\.\d+)?\z/
+        unless string =~ /\A-?\d*(\.\d+)?\z/ && !string.empty?
           raise Dentaku::ArgumentError.for(:invalid_value, value: string, for: BigDecimal),
                 "String input '#{string}' is not coercible to numeric"
         end
@@ -92,6 +94,14 @@ module Dentaku
       def self.precedence
         10
       end
+
+      def value(context = {})
+        if left.type == :datetime
+          Dentaku::DateArithmetic.new(left.value(context)).add(right.value(context))
+        else
+          super
+        end
+      end
     end
 
     class Subtraction < Arithmetic
@@ -102,6 +112,14 @@ module Dentaku
       def self.precedence
         10
       end
+
+      def value(context = {})
+        if left.type == :datetime
+          Dentaku::DateArithmetic.new(left.value(context)).sub(right.value(context))
+        else
+          super
+        end
+      end
     end
 
     class Multiplication < Arithmetic

data/lib/dentaku/ast/array.rb

@@ -4,6 +4,14 @@ module Dentaku
       def self.arity
       end
 
+      def self.min_param_count
+        0
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
       def self.peek(*)
       end
 
@@ -18,6 +26,10 @@ module Dentaku
       def dependencies(context = {})
         @elements.flat_map { |el| el.dependencies(context) }
       end
+
+      def type
+        nil
+      end
     end
   end
 end

data/lib/dentaku/ast/case.rb

@@ -8,6 +8,14 @@ require 'dentaku/exceptions'
 module Dentaku
   module AST
     class Case < Node
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
       def initialize(*nodes)
         @switch = nodes.shift
 

data/lib/dentaku/ast/case/case_conditional.rb

@@ -6,6 +6,14 @@ module Dentaku
       attr_reader :when,
                   :then
 
+      def self.min_param_count
+        2
+      end
+
+      def self.max_param_count
+        2
+      end
+
       def initialize(when_statement, then_statement)
         @when = when_statement
         unless @when.is_a?(AST::CaseWhen)

data/lib/dentaku/ast/function_registry.rb

@@ -38,6 +38,14 @@ module Dentaku
             @implementation.arity < 0 ? nil : @implementation.arity
           end
 
+          def self.min_param_count
+            @implementation.parameters.select { |type, _name| type == :req }.count
+          end
+
+          def self.max_param_count
+            @implementation.parameters.select { |type, _name| type == :rest }.any? ? Float::INFINITY : @implementation.parameters.count
+          end
+
           def value(context = {})
             args = @args.map { |a| a.value(context) }
             self.class.implementation.call(*args)
@@ -48,6 +56,8 @@ module Dentaku
           end
         end
 
+        define_class(name, function)
+
         function.name = name
         function.type = type
         function.implementation = implementation
@@ -72,6 +82,17 @@ module Dentaku
       def function_name(name)
         name.to_s.downcase
       end
+
+      def normalize_name(function_name)
+        function_name.to_s.capitalize.gsub(/\W/, '_')
+      end
+
+      def define_class(function_name, function)
+        class_name = normalize_name(function_name)
+        return if Dentaku::AST::Function.const_defined?(class_name)
+
+        Dentaku::AST::Function.const_set(class_name, function)
+      end
     end
   end
 end

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

@@ -3,6 +3,14 @@ require_relative '../function'
 module Dentaku
   module AST
     class Count < Function
+      def self.min_param_count
+        0
+      end
+
+      def self.max_param_count
+        Float::INFINITY
+      end
+
       def value(context = {})
         if @args.length == 1
           first_arg = @args[0].value(context)

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

@@ -0,0 +1,51 @@
+require_relative '../function'
+
+module Dentaku
+  module AST
+    class Duration < Function
+      def self.min_param_count
+        1
+      end
+
+      def self.max_param_count
+        1
+      end
+
+      class Value
+        attr_reader :value, :unit
+
+        def initialize(value, unit)
+          @value = value
+          @unit = validate_unit(unit)
+        end
+
+        def validate_unit(unit)
+          case unit.downcase
+          when /years?/ then :year
+          when /months?/ then :month
+          when /days?/ then :day
+          else
+            raise Dentaku::ArgumentError.for(:incompatible_type, value: unit, for: Duration),
+              "'#{unit || unit.class}' is not a valid duration unit"
+          end
+        end
+      end
+
+      def type
+        :duration
+      end
+
+      def value(context = {})
+        value_node, unit_node = *@args
+        Value.new(value_node.value(context), unit_node.identifier)
+      end
+
+      def dependencies(context = {})
+        value_node = @args.first
+        value_node.dependencies(context)
+      end
+    end
+  end
+end
+
+Dentaku::AST::Function.register_class(:duration, Dentaku::AST::Duration)

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

@@ -5,6 +5,14 @@ module Dentaku
     class If < Function
       attr_reader :predicate, :left, :right
 
+      def self.min_param_count
+        3
+      end
+
+      def self.max_param_count
+        3
+      end
+
       def initialize(predicate, left, right)
         @predicate = predicate
         @left      = left
@@ -24,8 +32,13 @@ module Dentaku
       end
 
       def dependencies(context = {})
-        # TODO : short-circuit?
-        (predicate.dependencies(context) + left.dependencies(context) + right.dependencies(context)).uniq
+        deps = predicate.dependencies(context)
+
+        if deps.empty?
+          predicate.value(context) ? left.dependencies(context) : right.dependencies(context)
+        else
+          (deps + left.dependencies(context) + right.dependencies(context)).uniq
+        end
       end
     end
   end

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

@@ -17,6 +17,14 @@ module Dentaku
       end
 
       class Left < Base
+        def self.min_param_count
+          2
+        end
+
+        def self.max_param_count
+          2
+        end
+
         def initialize(*args)
           super
           @string, @length = *@args
@@ -111,6 +119,14 @@ module Dentaku
       end
 
       class Concat < Base
+        def self.min_param_count
+          1
+        end
+
+        def self.max_param_count
+          Float::INFINITY
+        end
+
         def initialize(*args)
           super
         end

data/lib/dentaku/ast/identifier.rb

@@ -21,6 +21,8 @@ module Dentaku
         case v
         when Node
           v.value(context)
+        when Proc
+          v.call
         else
           v
         end

data/lib/dentaku/ast/node.rb

@@ -15,6 +15,10 @@ module Dentaku
       def dependencies(context = {})
         []
       end
+
+      def type
+        nil
+      end
     end
   end
 end

data/lib/dentaku/ast/operation.rb

@@ -5,6 +5,14 @@ module Dentaku
     class Operation < Node
       attr_reader :left, :right
 
+      def self.min_param_count
+        arity
+      end
+
+      def self.max_param_count
+        arity
+      end
+
       def initialize(left, right)
         @left  = left
         @right = right

data/lib/dentaku/date_arithmetic.rb

@@ -0,0 +1,45 @@
+module Dentaku
+  class DateArithmetic
+    def initialize(date)
+      @base = date
+    end
+
+    def add(duration)
+      case duration
+      when Numeric
+        @base + duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year + duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base >> duration.value
+        when :day
+          @base + duration.value
+        end
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+
+    def sub(duration)
+      case duration
+      when Numeric
+        @base - duration
+      when Dentaku::AST::Duration::Value
+        case duration.unit
+        when :year
+          Time.local(@base.year - duration.value, @base.month, @base.day).to_datetime
+        when :month
+          @base << duration.value
+        when :day
+          @base - duration.value
+        end
+      else
+        raise Dentaku::ArgumentError.for(:incompatible_type, value: duration, for: Numeric),
+          "'#{duration || duration.class}' is not coercible for date arithmetic"
+      end
+    end
+  end
+end

data/lib/dentaku/exceptions.rb

@@ -33,7 +33,7 @@ module Dentaku
     private_class_method :new
 
     VALID_REASONS = %i[
-      node_invalid too_few_operands undefined_function
+      node_invalid too_few_operands too_many_operands undefined_function
       unprocessed_token unknown_case_token unbalanced_bracket
       unbalanced_parenthesis unknown_grouping_token not_implemented_token_category
       invalid_statement

data/lib/dentaku/parser.rb

@@ -40,9 +40,17 @@ module Dentaku
       operator.peek(output)
 
       args_size = operator.arity || count
-      if args_size > output.length
-        fail! :too_few_operands, operator: operator, expect: args_size, actual: output.length
+      min_size = operator.arity || operator.min_param_count || count
+      max_size = operator.arity || operator.max_param_count || count
+
+      if output.length < min_size
+        fail! :too_few_operands, operator: operator, expect: min_size, actual: output.length
+      end
+
+      if output.length > max_size && operations.empty?
+        fail! :too_many_operands, operator: operator, expect: max_size, actual: output.length
       end
+
       args = Array.new(args_size) { output.pop }.reverse
 
       output.push operator.new(*args)
@@ -305,6 +313,8 @@ module Dentaku
           "#{meta.fetch(:operator)} requires #{meta.fetch(:expect).join(', ')} operands, but got #{meta.fetch(:actual)}"
         when :too_few_operands
           "#{meta.fetch(:operator)} has too few operands"
+        when :too_many_operands
+          "#{meta.fetch(:operator)} has too many operands"
         when :undefined_function
           "Undefined function #{meta.fetch(:function_name)}"
         when :unprocessed_token

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.3.2"
+  VERSION = "3.3.3"
 end

data/spec/ast/arithmetic_spec.rb

@@ -38,25 +38,33 @@ describe Dentaku::AST::Arithmetic do
     expect(neg(x)).to eq(-1)
   end
 
+  it 'correctly parses string operands to numeric values' do
+    expect(add(x, one, 'x' => '1')).to eq(2)
+    expect(add(x, one, 'x' => '1.1')).to eq(2.1)
+    expect(add(x, one, 'x' => '.1')).to eq(1.1)
+    expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+  end
+
   private
 
-  def add(left, right)
-    Dentaku::AST::Addition.new(left, right).value(ctx)
+  def add(left, right, context = ctx)
+    Dentaku::AST::Addition.new(left, right).value(context)
   end
 
-  def sub(left, right)
-    Dentaku::AST::Subtraction.new(left, right).value(ctx)
+  def sub(left, right, context = ctx)
+    Dentaku::AST::Subtraction.new(left, right).value(context)
   end
 
-  def mul(left, right)
-    Dentaku::AST::Multiplication.new(left, right).value(ctx)
+  def mul(left, right, context = ctx)
+    Dentaku::AST::Multiplication.new(left, right).value(context)
   end
 
-  def div(left, right)
-    Dentaku::AST::Division.new(left, right).value(ctx)
+  def div(left, right, context = ctx)
+    Dentaku::AST::Division.new(left, right).value(context)
   end
 
-  def neg(node)
-    Dentaku::AST::Negation.new(node).value(ctx)
+  def neg(node, context = ctx)
+    Dentaku::AST::Negation.new(node).value(context)
   end
 end

data/spec/ast/function_spec.rb

@@ -22,7 +22,7 @@ describe Dentaku::AST::Function do
   end
 
   describe "#arity" do
-    it "gives the correct arity for custom functions" do
+    it "returns the correct arity for custom functions" do
       zero = described_class.register("zero", :numeric, ->() { 0 })
       expect(zero.arity).to eq(0)
 

data/spec/ast/node_spec.rb

@@ -21,7 +21,10 @@ describe Dentaku::AST::Node do
     expect(node.dependencies).to eq(['x', 'y', 'z'])
 
     node = make_node('if(x > 5, y, z)')
-    expect(node.dependencies('x' => 7)).to eq(['y', 'z'])
+    expect(node.dependencies('x' => 7)).to eq(['y'])
+
+    node = make_node('if(x > 5, y, z)')
+    expect(node.dependencies('x' => 2)).to eq(['z'])
 
     node = make_node('')
     expect(node.dependencies).to eq([])

data/spec/calculator_spec.rb

@@ -74,6 +74,11 @@ describe Dentaku::Calculator do
       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
+
+    it 'supports lazy evaluation of variables' do
+      expect(calculator.evaluate('x + 1', x: -> { 1 })).to eq(2)
+      expect { calculator.evaluate('2', x: -> { raise 'boom' }) }.not_to raise_error
+    end
   end
 
   describe 'evaluate!' do
@@ -105,7 +110,7 @@ describe Dentaku::Calculator do
     end
 
     it 'raises argument error if a function is called with incorrect arity' do
-      expect { calculator.evaluate!('IF(a,b)', a: 1, b: 1) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('IF(a,b)', a: 1, b: 1) }.to raise_error(Dentaku::ParseError)
     end
   end
 
@@ -369,20 +374,34 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('some_boolean OR 7 < 5', some_boolean: false)).to be_falsey
   end
 
-  it 'compares Time variables' do
+  it 'compares time variables' do
     expect(calculator.evaluate('t1 < t2', t1: Time.local(2017, 1, 1).to_datetime, t2: Time.local(2017, 1, 2).to_datetime)).to be_truthy
     expect(calculator.evaluate('t1 < t2', t1: Time.local(2017, 1, 2).to_datetime, t2: Time.local(2017, 1, 1).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > t2', t1: Time.local(2017, 1, 1).to_datetime, t2: Time.local(2017, 1, 2).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > t2', t1: Time.local(2017, 1, 2).to_datetime, t2: Time.local(2017, 1, 1).to_datetime)).to be_truthy
   end
 
-  it 'compares Time literals with Time variables' do
+  it 'compares time literals with time variables' do
     expect(calculator.evaluate('t1 < 2017-01-02', t1: Time.local(2017, 1, 1).to_datetime)).to be_truthy
     expect(calculator.evaluate('t1 < 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 1).to_datetime)).to be_falsy
     expect(calculator.evaluate('t1 > 2017-01-02', t1: Time.local(2017, 1, 3).to_datetime)).to be_truthy
   end
 
+  it 'supports date arithmetic' do
+    expect(calculator.evaluate!('2020-01-01 + 30').to_date).to eq(Time.local(2020, 1, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 - 1').to_date).to eq(Time.local(2019, 12, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, day)').to_date).to eq(Time.local(2020, 1, 2).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, day)').to_date).to eq(Time.local(2019, 12, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, days)').to_date).to eq(Time.local(2020, 1, 31).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, month)').to_date).to eq(Time.local(2020, 2, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, month)').to_date).to eq(Time.local(2019, 12, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, months)').to_date).to eq(Time.local(2022, 7, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(1, year)').to_date).to eq(Time.local(2021, 1, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 - duration(1, year)').to_date).to eq(Time.local(2019, 1, 1).to_date)
+    expect(calculator.evaluate!('2020-01-01 + duration(30, years)').to_date).to eq(Time.local(2050, 1, 1).to_date)
+  end
+
   describe 'functions' do
     it 'include IF' do
       expect(calculator.evaluate('if(foo < 8, 10, 20)', foo: 2)).to eq(10)

data/spec/dentaku_spec.rb

@@ -36,4 +36,11 @@ describe Dentaku do
     Dentaku.aliases = { roundup: ['roundupup'] }
     expect(Dentaku.evaluate('roundupup(6.1)')).to eq(7)
   end
+
+  it 'sets caching opt-in flags' do
+    expect {
+      Dentaku.enable_caching!
+    }.to change { Dentaku.cache_ast? }.from(false).to(true)
+    .and change { Dentaku.cache_dependency_order? }.from(false).to(true)
+  end
 end

data/spec/external_function_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'dentaku'
 require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
@@ -14,6 +15,7 @@ describe Dentaku::Calculator do
           [: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)
@@ -39,6 +41,13 @@ describe Dentaku::Calculator 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(
@@ -59,6 +68,19 @@ describe Dentaku::Calculator do
       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 })
@@ -66,17 +88,19 @@ describe Dentaku::Calculator do
       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(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
 
-    it 'self.add_function 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)
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.3.2
+  version: 3.3.3
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2019-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -159,6 +159,7 @@ files:
 - lib/dentaku/ast/functions/and.rb
 - lib/dentaku/ast/functions/avg.rb
 - lib/dentaku/ast/functions/count.rb
+- lib/dentaku/ast/functions/duration.rb
 - lib/dentaku/ast/functions/if.rb
 - lib/dentaku/ast/functions/max.rb
 - lib/dentaku/ast/functions/min.rb
@@ -184,6 +185,7 @@ files:
 - lib/dentaku/ast/string.rb
 - lib/dentaku/bulk_expression_solver.rb
 - lib/dentaku/calculator.rb
+- lib/dentaku/date_arithmetic.rb
 - lib/dentaku/dependency_resolver.rb
 - lib/dentaku/exceptions.rb
 - lib/dentaku/flat_hash.rb
@@ -249,8 +251,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: dentaku
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A formula language parser and evaluator