dentaku 2.0.9 → 2.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc6a362189b735fe68596e1b94e28787d7290ac8
-  data.tar.gz: cec7635943905eaa4cb8cd888649f5c34a0c1871
+  metadata.gz: 0febf923ab551e0cfce23bc38794927a3acedbe2
+  data.tar.gz: 3b4db1f045f21acd1e6a7c864ed9a4c272a2f765
 SHA512:
-  metadata.gz: d82af702ad0a2b009680e7a3292388174915408f7d8e67c5b5cb0d545bd24544edd40a66a0611268bbb5614920c2de386784f8c7132c420802a1577d30b67a43
-  data.tar.gz: 417cd814e7f46973c312568e8dcd9dd4bbe9fe1dfa27abcb8ac178c58e78850c477d99f9a76abd285abd8141d1e647dceb52b40edcb54681743d9af95cde9684
+  metadata.gz: dad6f87cf37ba49f355b0e30b92a80dfc063eeb9444653ea09832066831dc09c19e022883b2c31c23189a1c46c842ce652fba133725fa4f887db1fb5a9becf2a
+  data.tar.gz: 5b01fa83b5ddd2f3123946196ff6f0be42f1bd196b38195249d24ee2c6e08c1ad077ffd0da2f2cf33dd9c664e447ffe6864ab0f021a79e30e51769189225ef53

data/.travis.yml

@@ -10,4 +10,4 @@ rvm:
   - 2.2.2
   - 2.2.3
   - 2.3.0
-  - rbx-2
+  - 2.4.0

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## [v2.0.11] 2017-05-08
+- fix dependency checking for logical AST nodes
+- make `CONCAT` variadic
+- fix casting strings to numeric in negation operations
+- add date/time support
+- add `&` (bitwise and) and `|` (bitwise or) operators
+- fix incompatibility with 'mathn' module
+- add `CONTAINS` string function
+
+## [v2.0.10] 2016-12-30
+- fix string function initialization bug
+- fix issues with CASE statements
+- allow injecting AST cache
+
 ## [v2.0.9] 2016-09-19
 - namespace tokenization errors
 - automatically coerce arguments to string functions as strings
@@ -111,6 +125,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v2.0.11]:  https://github.com/rubysolo/dentaku/compare/v2.0.10...v2.0.11
+[v2.0.10]:  https://github.com/rubysolo/dentaku/compare/v2.0.9...v2.0.10
 [v2.0.9]:  https://github.com/rubysolo/dentaku/compare/v2.0.8...v2.0.9
 [v2.0.8]:  https://github.com/rubysolo/dentaku/compare/v2.0.7...v2.0.8
 [v2.0.7]:  https://github.com/rubysolo/dentaku/compare/v2.0.6...v2.0.7

data/README.md

@@ -123,17 +123,19 @@ application, AST caching will consume more memory with each new formula.
 BUILT-IN OPERATORS AND FUNCTIONS
 ---------------------------------
 
-Math: `+`, `-`, `*`, `/`, `%`
+Math: `+`, `-`, `*`, `/`, `%`, `^`, `|`, `&`
 
-Logic: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`, `AND`, `OR`
+Also, all functions from Ruby's Math module, including `SIN`, `COS`, `TAN`, etc.
 
-Functions: `IF`, `NOT`, `MIN`, `MAX`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
+Comparison: `<`, `>`, `<=`, `>=`, `<>`, `!=`, `=`,
 
-Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L292))
+Logic: `IF`, `AND`, `OR`, `NOT`
+
+Functions: `MIN`, `MAX`, `ROUND`, `ROUNDDOWN`, `ROUNDUP`
 
-Math: all functions from Ruby's Math module, including `SIN`, `COS`, `TAN`, etc.
+Selections: `CASE` (syntax see [spec](https://github.com/rubysolo/dentaku/blob/master/spec/calculator_spec.rb#L292))
 
-String: `LEFT`, `RIGHT`, `MID`, `LEN`, `FIND`, `SUBSTITUTE`, `CONCAT`
+String: `LEFT`, `RIGHT`, `MID`, `LEN`, `FIND`, `SUBSTITUTE`, `CONCAT`, `CONTAINS`
 
 RESOLVING DEPENDENCIES
 ----------------------
@@ -277,7 +279,7 @@ LICENSE
 
 (The MIT License)
 
-Copyright © 2012-2016 Solomon White
+Copyright © 2012-2017 Solomon White
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the ‘Software’), to deal in

data/lib/dentaku/ast/arithmetic.rb

@@ -7,7 +7,7 @@ module Dentaku
     class Arithmetic < Operation
       def initialize(*)
         super
-        unless valid_node?(left) && valid_node?(right)
+        unless valid_left? && valid_right?
           fail ParseError, "#{ self.class } requires numeric operands"
         end
       end
@@ -16,6 +16,10 @@ module Dentaku
         :numeric
       end
 
+      def operator
+        raise "Not implemented"
+      end
+
       def value(context={})
         l = cast(left.value(context))
         r = cast(right.value(context))
@@ -24,21 +28,44 @@ module Dentaku
 
       private
 
-      def cast(value, prefer_integer=true)
-        validate_numeric(value)
-        v = BigDecimal.new(value, Float::DIG+1)
+      def cast(val, prefer_integer=true)
+        validate_operation(val)
+        validate_format(val) if val.is_a?(::String)
+        numeric(val, prefer_integer)
+      end
+
+      def numeric(val, prefer_integer)
+        v = BigDecimal.new(val, Float::DIG+1)
         v = v.to_i if prefer_integer && v.frac.zero?
         v
+      rescue ::TypeError
+        # If we got a TypeError BigDecimal or to_i failed;
+        # let value through so ruby things like Time - integer work
+        val
       end
 
       def valid_node?(node)
         node && (node.dependencies.any? || node.type == :numeric)
       end
 
-      def validate_numeric(value)
-        Float(value)
-      rescue ::ArgumentError, ::TypeError
-        fail Dentaku::ArgumentError, "#{ self.class } requires numeric operands"
+      def valid_left?
+        valid_node?(left)
+      end
+
+      def valid_right?
+        valid_node?(right)
+      end
+
+      def validate_operation(val)
+        unless val.respond_to?(operator)
+          fail Dentaku::ArgumentError, "#{ self.class } requires operands that respond to #{ operator }"
+        end
+      end
+
+      def validate_format(string)
+        unless string =~ /\A-?\d+(\.\d+)?\z/
+          fail Dentaku::ArgumentError, "String input '#{ string }' is not coercible to numeric"
+        end
       end
     end
 
@@ -73,6 +100,10 @@ module Dentaku
     end
 
     class Division < Arithmetic
+      def operator
+        :/
+      end
+
       def value(context={})
         r = cast(right.value(context), false)
         raise Dentaku::ZeroDivisionError if r.zero?
@@ -86,15 +117,6 @@ module Dentaku
     end
 
     class Modulo < Arithmetic
-      def initialize(left, right)
-        @left  = left
-        @right = right
-
-        unless (valid_node?(left) || left.nil?) && valid_node?(right)
-          fail ParseError, "#{ self.class } requires numeric operands"
-        end
-      end
-
       def percent?
         left.nil?
       end
@@ -114,6 +136,10 @@ module Dentaku
       def self.precedence
         20
       end
+
+      def valid_left?
+        valid_node?(left) || left.nil?
+      end
     end
 
     class Exponentiation < Arithmetic

data/lib/dentaku/ast/bitwise.rb

@@ -0,0 +1,17 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class BitwiseOr < Operation
+      def value(context={})
+        left.value(context) | right.value(context)
+      end
+    end
+
+    class BitwiseAnd < Operation
+      def value(context={})
+        left.value(context) & right.value(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/case.rb

@@ -43,9 +43,8 @@ module Dentaku
       def dependencies(context={})
         # TODO: should short-circuit
         @switch.dependencies(context) +
-          @conditions.flat_map do |condition|
-            condition.dependencies(context)
-          end
+          @conditions.flat_map { |condition| condition.dependencies(context) } +
+          @else.dependencies(context)
       end
     end
   end

data/lib/dentaku/ast/combinators.rb

@@ -17,7 +17,7 @@ module Dentaku
       private
 
       def valid_node?(node)
-        node.dependencies.any? || node.type == :logical
+        node && (node.dependencies.any? || node.type == :logical)
       end
     end
 

data/lib/dentaku/ast/datetime.rb

@@ -0,0 +1,8 @@
+require_relative "./literal"
+
+module Dentaku
+  module AST
+    class DateTime < Literal
+    end
+  end
+end

data/lib/dentaku/ast/function.rb

@@ -1,4 +1,5 @@
 require_relative 'node'
+require_relative 'function_registry'
 
 module Dentaku
   module AST
@@ -12,61 +13,19 @@ module Dentaku
       end
 
       def self.get(name)
-        registry.fetch(function_name(name)) {
-          fail ParseError, "Undefined function #{ name }"
-        }
+        registry.get(name)
       end
 
       def self.register(name, type, implementation)
-        function = Class.new(self) do
-          def self.implementation=(impl)
-            @implementation = impl
-          end
-
-          def self.implementation
-            @implementation
-          end
-
-          def self.type=(type)
-            @type = type
-          end
-
-          def self.type
-            @type
-          end
-
-          def value(context={})
-            args = @args.map { |a| a.value(context) }
-            self.class.implementation.call(*args)
-          end
-
-          def type
-            self.class.type
-          end
-        end
-
-        function_class = name.to_s.capitalize
-        Dentaku::AST.send(:remove_const, function_class) if Dentaku::AST.const_defined?(function_class)
-        Dentaku::AST.const_set(function_class, function)
-
-        function.implementation = implementation
-        function.type = type
-
-        registry[function_name(name)] = function
+        registry.register(name, type, implementation)
       end
 
       def self.register_class(name, function_class)
-        registry[function_name(name)] = function_class
-      end
-
-      private
-
-      def self.function_name(name)
-        name.to_s.downcase
+        registry.register_class(name, function_class)
       end
 
       def self.registry
-        @registry ||= {}
+        @registry ||= FunctionRegistry.new
       end
     end
   end

data/lib/dentaku/ast/function_registry.rb

@@ -0,0 +1,64 @@
+module Dentaku
+  module AST
+    class FunctionRegistry < Hash
+      def get(name)
+        name = function_name(name)
+        return self[name] if has_key?(name)
+        return default[name] if default.has_key?(name)
+        fail ParseError, "Undefined function #{ name }"
+      end
+
+      def register(name, type, implementation)
+        function = Class.new(Function) do
+          def self.implementation=(impl)
+            @implementation = impl
+          end
+
+          def self.implementation
+            @implementation
+          end
+
+          def self.type=(type)
+            @type = type
+          end
+
+          def self.type
+            @type
+          end
+
+          def value(context={})
+            args = @args.map { |a| a.value(context) }
+            self.class.implementation.call(*args)
+          end
+
+          def type
+            self.class.type
+          end
+        end
+
+        function.implementation = implementation
+        function.type = type
+
+        self[function_name(name)] = function
+      end
+
+      def register_class(name, function_class)
+        self[function_name(name)] = function_class
+      end
+
+      def default
+        self.class.default
+      end
+
+      def self.default
+        Dentaku::AST::Function.registry
+      end
+
+      private
+
+      def function_name(name)
+        name.to_s.downcase
+      end
+    end
+  end
+end

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

@@ -4,9 +4,9 @@ module Dentaku
   module AST
     module StringFunctions
       class Left < Function
-        def initialize(string, length)
-          @string = string
-          @length = length
+        def initialize(*args)
+          super
+          @string, @length = *@args
         end
 
         def value(context={})
@@ -17,9 +17,9 @@ module Dentaku
       end
 
       class Right < Function
-        def initialize(string, length)
-          @string = string
-          @length = length
+        def initialize(*args)
+          super
+          @string, @length = *@args
         end
 
         def value(context={})
@@ -30,10 +30,9 @@ module Dentaku
       end
 
       class Mid < Function
-        def initialize(string, offset, length)
-          @string = string
-          @offset = offset
-          @length = length
+        def initialize(*args)
+          super
+          @string, @offset, @length = *@args
         end
 
         def value(context={})
@@ -45,8 +44,9 @@ module Dentaku
       end
 
       class Len < Function
-        def initialize(string)
-          @string = string
+        def initialize(*args)
+          super
+          @string = @args[0]
         end
 
         def value(context={})
@@ -56,9 +56,9 @@ module Dentaku
       end
 
       class Find < Function
-        def initialize(needle, haystack)
-          @needle = needle
-          @haystack = haystack
+        def initialize(*args)
+          super
+          @needle, @haystack = *@args
         end
 
         def value(context={})
@@ -71,10 +71,9 @@ module Dentaku
       end
 
       class Substitute < Function
-        def initialize(original, search, replacement)
-          @original = original
-          @search = search
-          @replacement = replacement
+        def initialize(*args)
+          super
+          @original, @search, @replacement = *@args
         end
 
         def value(context={})
@@ -87,15 +86,23 @@ module Dentaku
       end
 
       class Concat < Function
-        def initialize(left, right)
-          @left  = left
-          @right = right
+        def initialize(*args)
+          super
         end
 
         def value(context={})
-          left = @left.value(context).to_s
-          right = @right.value(context).to_s
-          left + right
+          @args.map { |arg| arg.value(context).to_s }.join
+        end
+      end
+
+      class Contains < Function
+        def initialize(*args)
+          super
+          @needle, @haystack = *args
+        end
+
+        def value(context={})
+          @haystack.value(context).to_s.include? @needle.value(context).to_s
         end
       end
     end
@@ -109,3 +116,4 @@ Dentaku::AST::Function.register_class(:len,        Dentaku::AST::StringFunctions
 Dentaku::AST::Function.register_class(:find,       Dentaku::AST::StringFunctions::Find)
 Dentaku::AST::Function.register_class(:substitute, Dentaku::AST::StringFunctions::Substitute)
 Dentaku::AST::Function.register_class(:concat,     Dentaku::AST::StringFunctions::Concat)
+Dentaku::AST::Function.register_class(:contains,   Dentaku::AST::StringFunctions::Contains)

data/lib/dentaku/ast/negation.rb

@@ -1,13 +1,17 @@
 module Dentaku
   module AST
-    class Negation < Operation
+    class Negation < Arithmetic
       def initialize(node)
         @node = node
         fail ParseError, "Negation requires numeric operand" unless valid_node?(node)
       end
 
+      def operator
+        :*
+      end
+
       def value(context={})
-        @node.value(context) * -1
+        cast(@node.value(context)) * -1
       end
 
       def type

data/lib/dentaku/ast.rb

@@ -1,15 +1,18 @@
 require_relative './ast/node'
 require_relative './ast/nil'
+require_relative './ast/datetime'
 require_relative './ast/numeric'
 require_relative './ast/logical'
 require_relative './ast/string'
 require_relative './ast/identifier'
 require_relative './ast/arithmetic'
+require_relative './ast/bitwise'
 require_relative './ast/negation'
 require_relative './ast/comparators'
 require_relative './ast/combinators'
 require_relative './ast/grouping'
 require_relative './ast/case'
+require_relative './ast/function_registry'
 require_relative './ast/functions/if'
 require_relative './ast/functions/max'
 require_relative './ast/functions/min'

data/lib/dentaku/calculator.rb

@@ -4,19 +4,29 @@ require 'dentaku/token'
 require 'dentaku/dependency_resolver'
 require 'dentaku/parser'
 
+
 module Dentaku
   class Calculator
     attr_reader :result, :memory, :tokenizer
 
-    def initialize
+    def initialize(ast_cache={})
       clear
       @tokenizer = Tokenizer.new
-      @ast_cache = {}
+      @ast_cache = ast_cache
       @disable_ast_cache = false
+      @function_registry = Dentaku::AST::FunctionRegistry.new
+    end
+
+    def self.add_function(name, type, body)
+      Dentaku::AST::FunctionRegistry.default.register(name, type, body)
+    end
+
+    def add_functions(fns)
+      fns.each { |(name, type, body)| add_function(name, type, body) }
     end
 
     def add_function(name, type, body)
-      Dentaku::AST::Function.register(name, type, body)
+      @function_registry.register(name, type, body)
       self
     end
 
@@ -60,7 +70,7 @@ module Dentaku
 
     def ast(expression)
       @ast_cache.fetch(expression) {
-        Parser.new(tokenizer.tokenize(expression)).parse.tap do |node|
+        Parser.new(tokenizer.tokenize(expression), function_registry: @function_registry).parse.tap do |node|
           @ast_cache[expression] = node if cache_ast?
         end
       }
@@ -83,7 +93,7 @@ module Dentaku
       restore = Hash[memory]
 
       if value.nil?
-        key_or_hash.each do |key, val|
+        _flat_hash(key_or_hash).each do |key, val|
           memory[key.to_s.downcase] = val
         end
       else
@@ -120,5 +130,16 @@ module Dentaku
     def cache_ast?
       Dentaku.cache_ast? && !@disable_ast_cache
     end
+
+    private
+
+    def _flat_hash(hash, k = [])
+      if hash.is_a?(Hash)
+        hash.inject({}) { |h, v| h.merge! _flat_hash(v[-1], k + [v[0]]) }
+      else
+        return { k.join('.') => hash } if k.is_a?(Array)
+        { k => hash }
+      end
+    end
   end
 end

data/lib/dentaku/parser.rb

@@ -7,8 +7,9 @@ module Dentaku
     def initialize(tokens, options={})
       @input      = tokens.dup
       @output     = []
-      @operations = options.fetch(:operations, [])
-      @arities    = options.fetch(:arities, [])
+      @operations        = options.fetch(:operations, [])
+      @arities           = options.fetch(:arities, [])
+      @function_registry = options.fetch(:function_registry, nil)
     end
 
     def get_args(count)
@@ -25,6 +26,9 @@ module Dentaku
 
       while token = input.shift
         case token.category
+        when :datetime
+          output.push AST::DateTime.new(token)
+
         when :numeric
           output.push AST::Numeric.new(token)
 
@@ -67,15 +71,24 @@ module Dentaku
             # special handling for case nesting: strip out inner case
             # statements and parse their AST segments recursively
             if operations.include?(AST::Case)
-              last_case_close_index = nil
-              first_nested_case_close_index = nil
+              open_cases = 0
+              case_end_index = nil
+
               input.each_with_index do |token, index|
-                first_nested_case_close_index = last_case_close_index
+                if token.category == :case && token.value == :open
+                  open_cases += 1
+                end
+
                 if token.category == :case && token.value == :close
-                  last_case_close_index = index
+                  if open_cases > 0
+                    open_cases -= 1
+                  else
+                    case_end_index = index
+                    break
+                  end
                 end
               end
-              inner_case_inputs = input.slice!(0..first_nested_case_close_index)
+              inner_case_inputs = input.slice!(0..case_end_index)
               subparser = Parser.new(
                 inner_case_inputs,
                 operations: [AST::Case],
@@ -202,6 +215,8 @@ module Dentaku
         pow:      AST::Exponentiation,
         negate:   AST::Negation,
         mod:      AST::Modulo,
+        bitor:    AST::BitwiseOr,
+        bitand:   AST::BitwiseAnd,
 
         lt:       AST::LessThan,
         gt:       AST::GreaterThan,
@@ -216,7 +231,11 @@ module Dentaku
     end
 
     def function(token)
-      Dentaku::AST::Function.get(token.value)
+      function_registry.get(token.value)
+    end
+
+    def function_registry
+      @function_registry ||= Dentaku::AST::FunctionRegistry.new
     end
   end
 end

data/lib/dentaku/token_matcher.rb

@@ -93,11 +93,12 @@ module Dentaku
       @values.empty? || @values.key?(value)
     end
 
+    def self.datetime;       new(:datetime);                       end
     def self.numeric;        new(:numeric);                        end
     def self.string;         new(:string);                         end
     def self.logical;        new(:logical);                        end
     def self.value
-      new(:numeric) | new(:string) | new(:logical)
+      new(:datetime) | new(:numeric) | new(:string) | new(:logical)
     end
 
     def self.addsub;         new(:operator, [:add, :subtract]);    end

data/lib/dentaku/token_matchers.rb

@@ -12,7 +12,7 @@ module Dentaku
 
     def self.matcher(symbol)
       @matchers ||= [
-        :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
+        :datetime, :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
         :comparator, :comp_gt, :comp_lt, :open, :close, :comma,
         :non_close_plus, :non_group, :non_group_star, :arguments,
         :logical, :combinator, :if, :round, :roundup, :rounddown, :not,

data/lib/dentaku/token_scanner.rb

@@ -1,4 +1,5 @@
 require 'bigdecimal'
+require 'time'
 require 'dentaku/token'
 
 module Dentaku
@@ -28,6 +29,7 @@ module Dentaku
         [
           :null,
           :whitespace,
+          :datetime, # before numeric so it can pick up timestamps
           :numeric,
           :double_quoted_string,
           :single_quoted_string,
@@ -73,6 +75,11 @@ module Dentaku
         new(:null, 'null\b')
       end
 
+      # NOTE: Convert to DateTime as Array(Time) returns the parts of the time for some reason
+      def datetime
+        new(:datetime, /\d{2}\d{2}?-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}:\d{1,2})? ?(Z|((\+|\-)\d{2}\:?\d{2}))?/, lambda { |raw| Time.parse(raw).to_datetime })
+      end
+
       def numeric
         new(:numeric, '(\d+(\.\d+)?|\.\d+)\b', lambda { |raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
       end
@@ -97,8 +104,8 @@ module Dentaku
       end
 
       def operator
-        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%' }.invert
-        new(:operator, '\^|\+|-|\*|\/|%', lambda { |raw| names[raw] })
+        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&' }.invert
+        new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
       end
 
       def grouping
@@ -126,14 +133,14 @@ module Dentaku
       end
 
       def function
-        new(:function, '\w+\s*\(', lambda do |raw|
+        new(:function, '\w+!?\s*\(', lambda do |raw|
           function_name = raw.gsub('(', '')
           [Token.new(:function, function_name.strip.downcase.to_sym, function_name), Token.new(:grouping, :open, '(')]
         end)
       end
 
       def identifier
-        new(:identifier, '\w+\b', lambda { |raw| raw.strip.downcase })
+        new(:identifier, '[\w\.]+\b', lambda { |raw| raw.strip.downcase })
       end
     end
 

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.9"
+  VERSION = "2.0.11"
 end

data/spec/ast/addition_spec.rb

@@ -26,4 +26,31 @@ describe Dentaku::AST::Addition do
       described_class.new(group, five)
     }.not_to raise_error
   end
+
+  it 'allows operands that respond to addition' do
+    # Sample struct that has a custom definition for addition
+    
+    Operand = Struct.new(:value) do
+      def +(other)
+        case other
+        when Operand
+          value + other.value
+        when Numeric
+          value + other
+        end
+      end
+    end
+
+    operand_five = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, Operand.new(5))
+    operand_six = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, Operand.new(6))
+
+    expect {
+      described_class.new(operand_five, operand_six)
+    }.not_to raise_error
+
+    expect {
+      described_class.new(operand_five, six)
+    }.not_to raise_error
+
+  end
 end

data/spec/ast/case_spec.rb

@@ -67,14 +67,18 @@ describe Dentaku::AST::Case do
     let!(:tax) do
       Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :tax))
     end
+    let!(:fallback) do
+      Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :fallback))
+    end
     let!(:addition) { Dentaku::AST::Addition.new(two, tax) }
     let!(:when2) { Dentaku::AST::CaseWhen.new(banana) }
     let!(:then2) { Dentaku::AST::CaseThen.new(addition) }
+    let!(:else2) { Dentaku::AST::CaseElse.new(fallback) }
     let!(:conditional2) { Dentaku::AST::CaseConditional.new(when2, then2) }
 
     it 'gathers dependencies from switch and conditionals' do
-      node = described_class.new(switch, conditional1, conditional2)
-      expect(node.dependencies).to eq([:fruit, :tax])
+      node = described_class.new(switch, conditional1, conditional2, else2)
+      expect(node.dependencies).to eq([:fruit, :tax, :fallback])
     end
   end
 end

data/spec/ast/function_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'dentaku/ast/function'
 
+class Clazz; end
+
 describe Dentaku::AST::Function do
   it 'maintains a function registry' do
     expect(described_class).to respond_to(:get)
@@ -18,4 +20,8 @@ describe Dentaku::AST::Function do
     function = described_class.get("flarble").new
     expect(function.value).to eq "flarble"
   end
+
+  it 'does not throw an error when registering a function with a name that matches a currently defined constant' do
+    expect { described_class.register("clazz", :string, -> { "clazzified" }) }.not_to raise_error
+  end
 end

data/spec/ast/string_functions_spec.rb

@@ -133,3 +133,12 @@ describe Dentaku::AST::StringFunctions::Concat do
     expect(subject.value).to eq ''
   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
+end

data/spec/calculator_spec.rb

@@ -32,6 +32,9 @@ 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('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)
   end
 
   describe 'memory' do
@@ -59,6 +62,12 @@ describe Dentaku::Calculator do
       calculator.store_formula('area', 'length * width')
       expect(calculator.evaluate!('area', length: 5, width: 5)).to eq 25
     end
+
+    it 'stores nested hashes' do
+      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
   end
 
   describe 'dependencies' do
@@ -66,6 +75,12 @@ describe Dentaku::Calculator do
       expect(calculator.dependencies("bob + dole / 3")).to eq(['bob', 'dole'])
     end
 
+    it "finds dependencies in formula arguments" do
+      allow(Dentaku).to receive(:cache_ast?) { true }
+
+      expect(calculator.dependencies("CONCAT(bob, dole)")).to eq(['bob', 'dole'])
+    end
+
     it "doesn't consider variables in memory as dependencies" do
       expect(with_memory.dependencies("apples + oranges")).to eq(['oranges'])
     end
@@ -163,6 +178,14 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(1+1+1)/3*100')).to eq(100)
   end
 
+  it 'evaluates negation' do
+    expect(calculator.evaluate('-negative', negative: -1)).to eq(1)
+    expect(calculator.evaluate('-negative', negative: '-1')).to eq(1)
+    expect(calculator.evaluate('-negative - 1', negative: '-1')).to eq(0)
+    expect(calculator.evaluate('-negative - 1', negative: '1')).to eq(-2)
+    expect(calculator.evaluate('-(negative) - 1', negative: '1')).to eq(-2)
+  end
+
   it 'fails to evaluate unbound statements' do
     unbound = 'foo * 1.5'
     expect { calculator.evaluate!(unbound) }.to raise_error(Dentaku::UnboundVariableError)
@@ -174,6 +197,11 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate(unbound) { |e| e }).to eq unbound
   end
 
+  it 'fails to evaluate incomplete statements' do
+    incomplete = 'true AND'
+    expect { calculator.evaluate!(incomplete) }.to raise_error(Dentaku::ParseError)
+  end
+
   it 'evaluates unbound statements given a binding in memory' do
     expect(calculator.evaluate('foo * 1.5', foo: 2)).to eq(3)
     expect(calculator.bind(monkeys: 3).evaluate('monkeys < 7')).to be_truthy
@@ -217,6 +245,20 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('some_boolean OR 7 < 5', some_boolean: false)).to be_falsey
   end
 
+  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
+    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
+
   describe 'functions' do
     it 'include IF' do
       expect(calculator.evaluate('if(foo < 8, 10, 20)', foo: 2)).to eq(10)
@@ -275,16 +317,16 @@ describe Dentaku::Calculator do
     end
   end
 
-  describe 'explicit NULL' do
-    it 'can be used in IF statements' do
+  describe 'nil values' do
+    it 'can be used explicitly' do
       expect(calculator.evaluate('IF(null, 1, 2)')).to eq(2)
     end
 
-    it 'can be used in IF statements when passed in' do
+    it 'can be assigned to a variable' do
       expect(calculator.evaluate('IF(foo, 1, 2)', foo: nil)).to eq(2)
     end
 
-    it 'nil values are carried across middle terms' do
+    it 'are carried across middle terms' do
       results = calculator.solve!(
         choice: 'IF(bar, 1, 2)',
         bar: 'foo',
@@ -296,7 +338,7 @@ describe Dentaku::Calculator do
       )
     end
 
-    it 'raises errors when used in arithmetic operation' do
+    it 'raise errors when used in arithmetic operations' do
       expect {
         calculator.solve!(more_apples: "apples + 1", apples: nil)
       }.to raise_error(Dentaku::ArgumentError)
@@ -379,6 +421,34 @@ describe Dentaku::Calculator do
         fruit: 'banana')
       expect(value).to eq(5)
     end
+
+    it 'handles multiple nested case statements' do
+      formula = <<-FORMULA
+      CASE fruit
+      WHEN 'apple'
+        THEN
+        CASE quantity
+        WHEN 2 THEN 3
+        END
+      WHEN 'banana'
+        THEN
+        CASE quantity
+        WHEN 1 THEN 2
+        END
+      END
+      FORMULA
+      value = calculator.evaluate(
+        formula,
+        quantity: 1,
+        fruit: 'banana')
+      expect(value).to eq(2)
+
+      value = calculator.evaluate(
+        formula,
+        quantity: 2,
+        fruit: 'apple')
+      expect(value).to eq(3)
+    end
   end
 
   describe 'math functions' do
@@ -441,9 +511,9 @@ describe Dentaku::Calculator do
   end
 
   describe 'string functions' do
-    it 'concatenates two strings' do
+    it 'concatenates strings' do
       expect(
-        calculator.evaluate('CONCAT(s1, s2)', 's1' => 'abc', 's2' => 'def')
+        calculator.evaluate('CONCAT(s1, s2, s3)', 's1' => 'ab', 's2' => 'cd', 's3' => 'ef')
       ).to eq 'abcdef'
     end
   end

data/spec/dentaku_spec.rb

@@ -19,4 +19,10 @@ describe Dentaku do
     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
 end

data/spec/external_function_spec.rb

@@ -52,5 +52,29 @@ describe Dentaku::Calculator do
         expect(calculator.evaluate("INCLUDES(list, 2)", list: [1,2,3])).to eq(true)
       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 'does not store functions across all calculators' do
+      calculator1 = Dentaku::Calculator.new
+      calculator1.add_function(:my_function, :numeric, ->(x) { 2*x + 1 })
+
+      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{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)
+    end
   end
 end

data/spec/parser_spec.rb

@@ -35,6 +35,15 @@ describe Dentaku::Parser do
     expect(node.value).to eq 0.05
   end
 
+  it 'calculates bitwise OR' do
+    two   = Dentaku::Token.new(:numeric, 2)
+    bitor = Dentaku::Token.new(:operator, :bitor)
+    three = Dentaku::Token.new(:numeric, 3)
+
+    node  = described_class.new([two, bitor, three]).parse
+    expect(node.value).to eq 3
+  end
+
   it 'performs multiple operations in one stream' do
     five  = Dentaku::Token.new(:numeric, 5)
     plus  = Dentaku::Token.new(:operator, :add)
@@ -132,14 +141,25 @@ describe Dentaku::Parser do
     expect(node.value(x: 3)).to eq(4)
   end
 
-  it 'raises an error on parse failure' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    times = Dentaku::Token.new(:operator, :multiply)
-    minus = Dentaku::Token.new(:operator, :subtract)
-
-    expect {
-      described_class.new([five, times, minus]).parse
-    }.to raise_error(Dentaku::ParseError)
+  context 'invalid expression' do
+    it 'raises a parse error for bad math' do
+      five  = Dentaku::Token.new(:numeric, 5)
+      times = Dentaku::Token.new(:operator, :multiply)
+      minus = Dentaku::Token.new(:operator, :subtract)
+
+      expect {
+        described_class.new([five, times, minus]).parse
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error for bad logic' do
+      this = Dentaku::Token.new(:logical, true)
+      also = Dentaku::Token.new(:combinator, :and)
+
+      expect {
+        described_class.new([this, also]).parse
+      }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   it "evaluates explicit 'NULL' as a Nil" do

data/spec/token_scanner_spec.rb

@@ -28,7 +28,7 @@ describe Dentaku::TokenScanner do
   end
 
   it 'returns a list of all configured scanners' do
-    expect(described_class.scanners.length).to eq 14
+    expect(described_class.scanners.length).to eq 15
   end
 
   it 'allows customizing available scanners' do

data/spec/tokenizer_spec.rb

@@ -45,37 +45,43 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq(['number', :eq, 5])
   end
 
-  it 'tokenizes comparison with =' do
-    tokens = tokenizer.tokenize('number = 5')
-    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq(['number', :eq, 5])
-  end
-
   it 'tokenizes comparison with alternate ==' do
     tokens = tokenizer.tokenize('number == 5')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
     expect(tokens.map(&:value)).to eq(['number', :eq, 5])
   end
 
+  it 'tokenizes bitwise OR' do
+    tokens = tokenizer.tokenize('2 | 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitor, 3])
+  end
+
+  it 'tokenizes bitwise AND' do
+    tokens = tokenizer.tokenize('2 & 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitand, 3])
+  end
+
   it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([1, :divide, 1])
   end
 
-  it 'tokenizes power operations' do
+  it 'tokenizes power operations in simple expressions' do
     tokens = tokenizer.tokenize('10 ^ 2')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([10, :pow, 2])
   end
 
-  it 'tokenizes power operations' do
+  it 'tokenizes power operations in complex expressions' do
     tokens = tokenizer.tokenize('0 * 10 ^ -5')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric, :operator, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([0, :multiply, 10, :pow, :negate, 5])
   end
 
-  it 'handles floating point' do
+  it 'handles floating point operands' do
     tokens = tokenizer.tokenize('1.5 * 3.7')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([1.5, :multiply, 3.7])
@@ -111,13 +117,13 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq([2, :subtract, 3])
   end
 
-  it 'recognizes unary minus operator' do
+  it 'recognizes unary minus operator applied to left operand' do
     tokens = tokenizer.tokenize('-2 + 3')
     expect(tokens.map(&:category)).to eq([:operator, :numeric, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([:negate, 2, :add, 3])
   end
 
-  it 'recognizes unary minus operator' do
+  it 'recognizes unary minus operator applied to right operand' do
     tokens = tokenizer.tokenize('2 - -3')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :operator, :numeric])
     expect(tokens.map(&:value)).to eq([2, :subtract, :negate, 3])
@@ -165,6 +171,22 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq(['true_lies', :and, 'falsehoods'])
   end
 
+  it 'tokenizes Time literals' do
+    tokens = tokenizer.tokenize('2017-01-01 2017-01-2 2017-1-03 2017-01-04 12:23:42 2017-1-5 1:2:3 2017-1-06 1:02:30 2017-01-07 12:34:56 Z 2017-01-08 1:2:3 +0800')
+    expect(tokens.length).to eq(8)
+    expect(tokens.map(&:category)).to eq([:datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime])
+    expect(tokens.map(&:value)).to eq([
+      Time.local(2017, 1, 1).to_datetime,
+      Time.local(2017, 1, 2).to_datetime,
+      Time.local(2017, 1, 3).to_datetime,
+      Time.local(2017, 1, 4, 12, 23, 42).to_datetime,
+      Time.local(2017, 1, 5, 1, 2, 3).to_datetime,
+      Time.local(2017, 1, 6, 1, 2, 30).to_datetime,
+      Time.utc(2017, 1, 7, 12, 34, 56).to_datetime,
+      Time.new(2017, 1, 8, 1, 2, 3, "+08:00").to_datetime
+    ])
+  end
+
   describe 'functions' do
     it 'include IF' do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')
@@ -208,5 +230,12 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
       expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
+
+    it 'can end with a bang' do
+      tokens = tokenizer.tokenize('exp!(5 * 3)')
+      expect(tokens.length).to eq(6)
+      expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :operator, :numeric, :grouping])
+      expect(tokens.map(&:value)).to eq([:exp!, :open, 5, :multiply, 3, :close])
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 2.0.9
+  version: 2.0.11
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-19 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -70,6 +70,7 @@ files:
 - lib/dentaku.rb
 - lib/dentaku/ast.rb
 - lib/dentaku/ast/arithmetic.rb
+- lib/dentaku/ast/bitwise.rb
 - lib/dentaku/ast/case.rb
 - lib/dentaku/ast/case/case_conditional.rb
 - lib/dentaku/ast/case/case_else.rb
@@ -78,7 +79,9 @@ files:
 - lib/dentaku/ast/case/case_when.rb
 - lib/dentaku/ast/combinators.rb
 - lib/dentaku/ast/comparators.rb
+- lib/dentaku/ast/datetime.rb
 - lib/dentaku/ast/function.rb
+- lib/dentaku/ast/function_registry.rb
 - lib/dentaku/ast/functions/if.rb
 - lib/dentaku/ast/functions/max.rb
 - lib/dentaku/ast/functions/min.rb