dentaku 3.2.0 → 3.5.1

data/lib/dentaku/exceptions.rb

@@ -1,7 +1,9 @@
 module Dentaku
-  class UnboundVariableError < StandardError
+  class Error < StandardError
     attr_accessor :recipient_variable
+  end
 
+  class UnboundVariableError < Error
     attr_reader :unbound_variables
 
     def initialize(unbound_variables)
@@ -9,7 +11,7 @@ module Dentaku
     end
   end
 
-  class NodeError < StandardError
+  class NodeError < Error
     attr_reader :child, :expect, :actual
 
     def initialize(expect, actual, child)
@@ -19,7 +21,7 @@ module Dentaku
     end
   end
 
-  class ParseError < StandardError
+  class ParseError < Error
     attr_reader :reason, :meta
 
     def initialize(reason, **meta)
@@ -30,7 +32,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
@@ -41,11 +43,11 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 
-  class TokenizerError < StandardError
+  class TokenizerError < Error
     attr_reader :reason, :meta
 
     def initialize(reason, **meta)
@@ -65,12 +67,13 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 
   class ArgumentError < ::ArgumentError
     attr_reader :reason, :meta
+    attr_accessor :recipient_variable
 
     def initialize(reason, **meta)
       @reason = reason
@@ -89,7 +92,7 @@ module Dentaku
         raise ::ArgumentError, "Unhandled #{reason}"
       end
 
-      new reason, meta
+      new(reason, **meta)
     end
   end
 

data/lib/dentaku/flat_hash.rb

@@ -6,6 +6,13 @@ module Dentaku
       flatten_keys(acc)
     end
 
+    def self.from_hash_with_intermediates(h, key = [], acc = {})
+      acc.update(key => h) unless key.empty?
+      return unless h.is_a? Hash
+      h.each { |k, v| from_hash_with_intermediates(v, key + [k], acc) }
+      flatten_keys(acc)
+    end
+
     def self.flatten_keys(hash)
       hash.each_with_object({}) do |(k, v), h|
         h[flatten_key(k)] = v
@@ -19,8 +26,8 @@ module Dentaku
       key
     end
 
-    def self.expand(h)
-      h.each_with_object({}) do |(k, v), r|
+    def self.expand(hash)
+      hash.each_with_object({}) do |(k, v), r|
         hash_levels = k.to_s.split('.')
         hash_levels = hash_levels.map(&:to_sym) if k.is_a?(Symbol)
         child_hash = hash_levels[0...-1].reduce(r) { |h, n| h[n] ||= {} }

data/lib/dentaku/parser.rb

@@ -10,8 +10,11 @@ module Dentaku
       pow:      AST::Exponentiation,
       negate:   AST::Negation,
       mod:      AST::Modulo,
+
       bitor:    AST::BitwiseOr,
       bitand:   AST::BitwiseAnd,
+      bitshiftleft:  AST::BitwiseShiftLeft,
+      bitshiftright: AST::BitwiseShiftRight,
 
       lt:       AST::LessThan,
       gt:       AST::GreaterThan,
@@ -22,6 +25,7 @@ module Dentaku
 
       and:      AST::And,
       or:       AST::Or,
+      xor:      AST::Xor,
     }.freeze
 
     attr_reader :input, :output, :operations, :arities, :case_sensitive
@@ -37,15 +41,28 @@ module Dentaku
 
     def consume(count = 2)
       operator = operations.pop
+      fail! :invalid_statement if operator.nil?
+
       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 || args_size < min_size
+        fail! :too_few_operands, operator: operator, expect: min_size, actual: output.length
+      end
+
+      if output.length > max_size && operations.empty? || args_size > max_size
+        fail! :too_many_operands, operator: operator, expect: max_size, actual: output.length
       end
+
+      fail! :invalid_statement if output.size < args_size
       args = Array.new(args_size) { output.pop }.reverse
 
       output.push operator.new(*args)
+    rescue ::ArgumentError => e
+      raise Dentaku::ArgumentError, e.message
     rescue NodeError => e
       fail! :node_invalid, operator: operator, child: e.child, expect: e.expect, actual: e.actual
     end
@@ -111,17 +128,19 @@ module Dentaku
               open_cases = 0
               case_end_index = nil
 
-              input.each_with_index do |token, index|
-                if token.category == :case && token.value == :open
-                  open_cases += 1
-                end
+              input.each_with_index do |input_token, index|
+                if input_token.category == :case
+                  if input_token.value == :open
+                    open_cases += 1
+                  end
 
-                if token.category == :case && token.value == :close
-                  if open_cases > 0
-                    open_cases -= 1
-                  else
-                    case_end_index = index
-                    break
+                  if input_token.value == :close
+                    if open_cases > 0
+                      open_cases -= 1
+                    else
+                      case_end_index = index
+                      break
+                    end
                   end
                 end
               end
@@ -129,7 +148,9 @@ module Dentaku
               subparser = Parser.new(
                 inner_case_inputs,
                 operations: [AST::Case],
-                arities: [0]
+                arities: [0],
+                function_registry: @function_registry,
+                case_sensitive: case_sensitive
               )
               subparser.parse
               output.concat(subparser.output)
@@ -205,11 +226,28 @@ module Dentaku
             end
 
             unless operations.last == AST::Access
-              fail! :unbalanced_bracket, token
+              fail! :unbalanced_bracket, token: token
             end
             consume
           end
 
+        when :array
+          case token.value
+          when :array_start
+            operations.push AST::Array
+            arities.push 0
+          when :array_end
+            while operations.any? && operations.last != AST::Array
+              consume
+            end
+
+            unless operations.last == AST::Array
+              fail! :unbalanced_bracket, token: token
+            end
+
+            consume(arities.pop.succ)
+          end
+
         when :grouping
           case token.value
           when :open
@@ -236,8 +274,9 @@ module Dentaku
             end
 
           when :comma
+            fail! :invalid_statement if arities.empty?
             arities[-1] += 1
-            while operations.any? && operations.last != AST::Grouping
+            while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
               consume
             end
 
@@ -282,6 +321,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
@@ -302,7 +343,7 @@ module Dentaku
           raise ::ArgumentError, "Unhandled #{reason}"
         end
 
-      raise ParseError.for(reason, meta), message
+      raise ParseError.for(reason, **meta), message
     end
   end
 end

data/lib/dentaku/print_visitor.rb

@@ -0,0 +1,101 @@
+module Dentaku
+  class PrintVisitor
+    def initialize(node)
+      @output = ''
+      node.accept(self)
+    end
+
+    def visit_operation(node)
+      if node.left
+        visit_operand(node.left, node.class.precedence, suffix: " ")
+      end
+
+      @output << node.display_operator
+
+      if node.right
+        visit_operand(node.right, node.class.precedence, prefix: " ")
+      end
+    end
+
+    def visit_operand(node, precedence, prefix: "", suffix: "")
+      @output << prefix
+      @output << "(" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      node.accept(self)
+      @output << ")" if node.is_a?(Dentaku::AST::Operation) && node.class.precedence < precedence
+      @output << suffix
+    end
+
+    def visit_function(node)
+      @output << node.name
+      @output << "("
+      arg_count = node.args.length
+      node.args.each_with_index do |a, index|
+        a.accept(self)
+        @output << ", " unless index >= arg_count - 1
+      end
+      @output << ")"
+    end
+
+    def visit_case(node)
+      @output << "CASE "
+      node.switch.accept(self)
+      node.conditions.each { |c| c.accept(self) }
+      node.else && node.else.accept(self)
+      @output << " END"
+    end
+
+    def visit_switch(node)
+      node.node.accept(self)
+    end
+
+    def visit_case_conditional(node)
+      node.when.accept(self)
+      node.then.accept(self)
+    end
+
+    def visit_when(node)
+      @output << " WHEN "
+      node.node.accept(self)
+    end
+
+    def visit_then(node)
+      @output << " THEN "
+      node.node.accept(self)
+    end
+
+    def visit_else(node)
+      @output << " ELSE "
+      node.node.accept(self)
+    end
+
+    def visit_negation(node)
+      @output << "-"
+      @output << "(" unless node.node.is_a? Dentaku::AST::Literal
+      node.node.accept(self)
+      @output << ")" unless node.node.is_a? Dentaku::AST::Literal
+    end
+
+    def visit_access(node)
+      node.structure.accept(self)
+      @output << "["
+      node.index.accept(self)
+      @output << "]"
+    end
+
+    def visit_literal(node)
+      @output << node.quoted
+    end
+
+    def visit_identifier(node)
+      @output << node.identifier
+    end
+
+    def visit_nil(node)
+      @output << "NULL"
+    end
+
+    def to_s
+      @output
+    end
+  end
+end

data/lib/dentaku/token_matcher.rb

@@ -16,7 +16,7 @@ module Dentaku
       @range = (@min..@max)
     end
 
-    def | (other_matcher)
+    def |(other_matcher)
       self.class.new(:nomatch, :nomatch, leaf_matchers + other_matcher.leaf_matchers)
     end
 

data/lib/dentaku/token_scanner.rb

@@ -43,6 +43,7 @@ module Dentaku
           :combinator,
           :operator,
           :grouping,
+          :array,
           :access,
           :case_statement,
           :comparator,
@@ -90,7 +91,7 @@ module Dentaku
 
       def numeric
         new(:numeric, '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b', lambda { |raw|
-          raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i
+          raw =~ /(\.|e|E)/ ? BigDecimal(raw) : raw.to_i
         })
       end
 
@@ -119,9 +120,9 @@ module Dentaku
 
       def operator
         names = {
-          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&'
+          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&', bitshiftleft: '<<', bitshiftright: '>>'
         }.invert
-        new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
+        new(:operator, '\^|\+|-|\*|\/|%|\||&|<<|>>', lambda { |raw| names[raw] })
       end
 
       def grouping
@@ -129,6 +130,11 @@ module Dentaku
         new(:grouping, '\(|\)|,', lambda { |raw| names[raw] })
       end
 
+      def array
+        names = { array_start: '{', array_end: '}', }.invert
+        new(:array, '\{|\}|,', lambda { |raw| names[raw] })
+      end
+
       def access
         names = { lbracket: '[', rbracket: ']' }.invert
         new(:access, '\[|\]', lambda { |raw| names[raw] })

data/lib/dentaku/tokenizer.rb

@@ -12,7 +12,7 @@ module Dentaku
     def tokenize(string, options = {})
       @nesting = 0
       @tokens  = []
-      @aliases = options.fetch(:aliases, Dentaku.aliases)
+      @aliases = options.fetch(:aliases, global_aliases)
       input    = strip_comments(string.to_s.dup)
       input    = replace_aliases(input)
       @case_sensitive = options.fetch(:case_sensitive, false)
@@ -84,6 +84,11 @@ module Dentaku
 
     private
 
+    def global_aliases
+      return {} unless Dentaku.respond_to?(:aliases)
+      Dentaku.aliases
+    end
+
     def fail!(reason, **meta)
       message =
         case reason
@@ -99,7 +104,7 @@ module Dentaku
           raise ::ArgumentError, "Unhandled #{reason}"
         end
 
-      raise TokenizerError.for(reason, meta), message
+      raise TokenizerError.for(reason, **meta), message
     end
   end
 end

data/lib/dentaku/version.rb

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

data/lib/dentaku/visitor/infix.rb

@@ -0,0 +1,82 @@
+# infix visitor
+#
+# use this visitor in a processor to get infix visiting order
+#
+#  visitor     node     deps
+#    accept ->   visit left ->
+#                process
+#                visit right ->
+module Dentaku
+  module Visitor
+    module Infix
+      def visit(ast)
+        ast.accept(self)
+      end
+
+      def process(_ast)
+        raise NotImplementedError
+      end
+
+      def visit_function(node)
+        node.args.each do |arg|
+          visit(arg)
+        end
+        process(node)
+      end
+
+      def visit_identifier(node)
+        process(node)
+      end
+
+      def visit_operation(node)
+        visit(node.left) if node.left
+        process(node)
+        visit(node.right) if node.right
+      end
+
+      def visit_operand(node)
+        process(node)
+      end
+
+      def visit_case(node)
+        process(node)
+      end
+
+      def visit_switch(node)
+        process(node)
+        end
+
+      def visit_case_conditional(node)
+        process(node)
+      end
+
+      def visit_when(node)
+        process(node)
+      end
+
+      def visit_then(node)
+        process(node)
+      end
+
+      def visit_else(node)
+        process(node)
+      end
+
+      def visit_negation(node)
+        process(node)
+      end
+
+      def visit_access(node)
+        process(node)
+      end
+
+      def visit_literal(node)
+        process(node)
+      end
+
+      def visit_nil(node)
+        process(node)
+      end
+    end
+  end
+end

data/lib/dentaku.rb

@@ -1,23 +1,26 @@
 require "bigdecimal"
+require "concurrent"
 require "dentaku/calculator"
 require "dentaku/version"
 
 module Dentaku
   @enable_ast_caching = false
   @enable_dependency_order_caching = false
+  @enable_identifier_caching = false
   @aliases = {}
 
-  def self.evaluate(expression, data = {})
-    calculator.evaluate(expression, data)
+  def self.evaluate(expression, data = {}, &block)
+    calculator.value.evaluate(expression, data, &block)
   end
 
-  def self.evaluate!(expression, data = {})
-    calculator.evaluate!(expression, data)
+  def self.evaluate!(expression, data = {}, &block)
+    calculator.value.evaluate!(expression, data, &block)
   end
 
   def self.enable_caching!
     enable_ast_cache!
     enable_dependency_order_cache!
+    enable_identifier_cache!
   end
 
   def self.enable_ast_cache!
@@ -36,6 +39,14 @@ module Dentaku
     @enable_dependency_order_caching
   end
 
+  def self.enable_identifier_cache!
+    @enable_identifier_caching = true
+  end
+
+  def self.cache_identifier?
+    @enable_identifier_caching
+  end
+
   def self.aliases
     @aliases
   end
@@ -44,13 +55,15 @@ module Dentaku
     @aliases = hash
   end
 
-  private
-
   def self.calculator
-    @calculator ||= Dentaku::Calculator.new
+    @calculator ||= Concurrent::ThreadLocalVar.new { Dentaku::Calculator.new }
   end
 end
 
 def Dentaku(expression, data = {})
   Dentaku.evaluate(expression, data)
 end
+
+def Dentaku!(expression, data = {})
+  Dentaku.evaluate!(expression, data)
+end

data/spec/ast/addition_spec.rb

@@ -9,9 +9,15 @@ describe Dentaku::AST::Addition do
 
   let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
 
+  it 'allows access to its sub-trees' do
+    node = described_class.new(five, six)
+    expect(node.left).to eq(five)
+    expect(node.right).to eq(six)
+  end
+
   it 'performs addition' do
     node = described_class.new(five, six)
-    expect(node.value).to eq 11
+    expect(node.value).to eq(11)
   end
 
   it 'requires numeric operands' do

data/spec/ast/all_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/all'
+require 'dentaku'
+
+describe Dentaku::AST::All do
+  let(:calculator) { Dentaku::Calculator.new }
+  it 'performs ALL operation' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(false)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ArgumentError, 'ALL() requires second argument to be an identifier'
+    )
+  end
+end

data/spec/ast/and_function_spec.rb

@@ -7,29 +7,29 @@ describe 'Dentaku::AST::And' do
 
   it 'returns false if any of the arguments is false' do
     result = Dentaku('AND(1 = 1, 0 = 1)')
-    expect(result).to eq false
+    expect(result).to eq(false)
   end
 
   it 'supports nested expressions' do
     result = Dentaku('AND(y = 1, x = 1)', x: 1, y: 2)
-    expect(result).to eq false
+    expect(result).to eq(false)
   end
 
   it 'returns true if all of the arguments are true' do
     result = Dentaku('AND(1 = 1, "2" = "2", true = true, true)')
-    expect(result).to eq true
+    expect(result).to eq(true)
   end
 
   it 'returns true if all nested AND functions return true' do
     result = Dentaku('AND(AND(1 = 1), AND(true != false, AND(true)))')
-    expect(result).to eq true
+    expect(result).to eq(true)
   end
 
   it 'raises an error if no arguments are passed' do
-    expect { calculator.evaluate!('AND()') }.to raise_error(ArgumentError)
+    expect { calculator.evaluate!('AND()') }.to raise_error(Dentaku::ArgumentError)
   end
 
   it 'raises an error if a non logical argument is passed' do
-    expect { calculator.evaluate!('AND("r")') }.to raise_error(ArgumentError)
+    expect { calculator.evaluate!('AND("r")') }.to raise_error(Dentaku::ArgumentError)
   end
 end

data/spec/ast/and_spec.rb

@@ -11,7 +11,7 @@ describe Dentaku::AST::And do
 
   it 'performs logical AND' do
     node = described_class.new(t, f)
-    expect(node.value).to eq false
+    expect(node.value).to eq(false)
   end
 
   it 'requires logical operands' do