dentaku 2.0.10 → 2.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2b19bb69372e3700ffb09ca14b5f3fbcb630b06
-  data.tar.gz: 4a67960044c94875d8a0ab2487e9464c820af5ca
+  metadata.gz: 0febf923ab551e0cfce23bc38794927a3acedbe2
+  data.tar.gz: 3b4db1f045f21acd1e6a7c864ed9a4c272a2f765
 SHA512:
-  metadata.gz: 017f2d92d2b8110151d51ea2c93abe8964a82a662b40ce1f38a8133b75dea64b51ba774f64d06ffb24353024046eeb59457d239527560a57eeb0671b6dff8cc1
-  data.tar.gz: cd39bb1acee73e4b05d65940310749601bf758c8797c2cca5ed4e45f6850b59a0637b132a8c4eafd0b60ac52a8714ad5b6933ca38fe3dcc0e60ef9588d2565c0
+  metadata.gz: dad6f87cf37ba49f355b0e30b92a80dfc063eeb9444653ea09832066831dc09c19e022883b2c31c23189a1c46c842ce652fba133725fa4f887db1fb5a9becf2a
+  data.tar.gz: 5b01fa83b5ddd2f3123946196ff6f0be42f1bd196b38195249d24ee2c6e08c1ad077ffd0da2f2cf33dd9c664e447ffe6864ab0f021a79e30e51769189225ef53

data/.travis.yml

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

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # 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
@@ -116,7 +125,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
-[HEAD]:  https://github.com/rubysolo/dentaku/compare/v2.0.9...HEAD
+[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.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/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/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, false)
-        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

@@ -88,13 +88,21 @@ module Dentaku
       class Concat < Function
         def initialize(*args)
           super
-          @left, @right = *@args
         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
@@ -108,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/calculator.rb

@@ -4,6 +4,7 @@ require 'dentaku/token'
 require 'dentaku/dependency_resolver'
 require 'dentaku/parser'
 
+
 module Dentaku
   class Calculator
     attr_reader :result, :memory, :tokenizer
@@ -13,10 +14,19 @@ module Dentaku
       @tokenizer = Tokenizer.new
       @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)
 
@@ -211,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,
@@ -225,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.10"
+  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/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
@@ -169,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)
@@ -180,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
@@ -223,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)
@@ -281,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',
@@ -302,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)
@@ -475,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.10
+  version: 2.0.11
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-30 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