dentaku 3.0.0 → 3.1.0

data/lib/dentaku/ast/operation.rb

@@ -10,7 +10,7 @@ module Dentaku
         @right = right
       end
 
-      def dependencies(context={})
+      def dependencies(context = {})
         (left.dependencies(context) + right.dependencies(context)).uniq
       end
 

data/lib/dentaku/bulk_expression_solver.rb

@@ -1,13 +1,14 @@
 require 'dentaku/dependency_resolver'
 require 'dentaku/exceptions'
+require 'dentaku/flat_hash'
 require 'dentaku/parser'
 require 'dentaku/tokenizer'
 
 module Dentaku
   class BulkExpressionSolver
-    def initialize(expression_hash, calculator)
-      self.expression_hash = expression_hash
-      self.calculator = calculator
+    def initialize(expressions, calculator)
+      @expression_hash = FlatHash.from_hash(expressions)
+      @calculator = calculator
     end
 
     def solve!
@@ -18,8 +19,19 @@ module Dentaku
       error_handler = block || return_undefined_handler
       results = load_results(&error_handler)
 
-      expression_hash.each_with_object({}) do |(k, _), r|
-        r[k] = results[k.to_s]
+      FlatHash.expand(
+        expression_hash.each_with_object({}) do |(k, _), r|
+          r[k] = results[k.to_s]
+        end
+      )
+    end
+
+    def dependencies
+      Hash[expression_deps].tap do |d|
+        d.values.each do |deps|
+          unresolved = deps.reject { |ud| d.has_key?(ud) }
+          unresolved.each { |u| add_dependencies(d, u) }
+        end
       end
     end
 
@@ -29,7 +41,7 @@ module Dentaku
       @dep_cache ||= {}
     end
 
-    attr_accessor :expression_hash, :calculator
+    attr_reader :expression_hash, :calculator
 
     def return_undefined_handler
       ->(*) { :undefined }
@@ -39,38 +51,45 @@ module Dentaku
       ->(ex) { raise ex }
     end
 
+    def expression_with_exception_handler(&block)
+      ->(expr, ex) { block.call(ex) }
+    end
+
     def load_results(&block)
       variables_in_resolve_order.each_with_object({}) do |var_name, r|
         begin
-          value_from_memory = calculator.memory[var_name]
+          solved = calculator.memory
+          value_from_memory = solved[var_name.downcase]
 
           if value_from_memory.nil? &&
               expressions[var_name].nil? &&
-              !calculator.memory.has_key?(var_name)
+              !solved.has_key?(var_name)
             next
           end
 
-          value = value_from_memory ||
-            evaluate!(expressions[var_name], expressions.merge(r))
+          value = value_from_memory || evaluate!(
+            expressions[var_name],
+            expressions.merge(r).merge(solved),
+            &expression_with_exception_handler(&block)
+          )
 
           r[var_name] = value
         rescue UnboundVariableError, Dentaku::ZeroDivisionError => ex
           ex.recipient_variable = var_name
           r[var_name] = block.call(ex)
+        rescue Dentaku::ArgumentError => ex
+          r[var_name] = block.call(ex)
         end
       end
     end
 
     def expressions
-      @expressions ||= Hash[expression_hash.map { |k,v| [k.to_s, v] }]
+      @expressions ||= Hash[expression_hash.map { |k, v| [k.to_s, v] }]
     end
 
-    def expression_dependencies
-      Hash[expressions.map { |var, expr| [var, calculator.dependencies(expr)] }].tap do |d|
-        d.values.each do |deps|
-          unresolved = deps.reject { |ud| d.has_key?(ud) }
-          unresolved.each { |u| add_dependencies(d, u) }
-        end
+    def expression_deps
+      expressions.map do |var, expr|
+        [var, calculator.dependencies(expr)]
       end
     end
 
@@ -85,14 +104,14 @@ module Dentaku
     def variables_in_resolve_order
       cache_key = expressions.keys.map(&:to_s).sort.join("|")
       @ordered_deps ||= self.class.dependency_cache.fetch(cache_key) {
-        DependencyResolver.find_resolve_order(expression_dependencies).tap do |d|
+        DependencyResolver.find_resolve_order(dependencies).tap do |d|
           self.class.dependency_cache[cache_key] = d if Dentaku.cache_dependency_order?
         end
       }
     end
 
-    def evaluate!(expression, results)
-      calculator.evaluate!(expression, results)
+    def evaluate!(expression, results, &block)
+      calculator.evaluate!(expression, results, &block)
     end
   end
 end

data/lib/dentaku/calculator.rb

@@ -1,18 +1,24 @@
 require 'dentaku/bulk_expression_solver'
-require 'dentaku/exceptions'
-require 'dentaku/token'
 require 'dentaku/dependency_resolver'
+require 'dentaku/exceptions'
+require 'dentaku/flat_hash'
 require 'dentaku/parser'
-
+require 'dentaku/string_casing'
+require 'dentaku/token'
 
 module Dentaku
   class Calculator
-    attr_reader :result, :memory, :tokenizer
+    include StringCasing
+    attr_reader :result, :memory, :tokenizer, :case_sensitive, :aliases, :nested_data_support
 
-    def initialize(ast_cache={})
+    def initialize(options = {})
       clear
       @tokenizer = Tokenizer.new
-      @ast_cache = ast_cache
+      @case_sensitive = options.delete(:case_sensitive)
+      @aliases = options.delete(:aliases) || Dentaku.aliases
+      @nested_data_support = options.fetch(:nested_data_support, true)
+      options.delete(:nested_data_support)
+      @ast_cache = options
       @disable_ast_cache = false
       @function_registry = Dentaku::AST::FunctionRegistry.new
     end
@@ -38,13 +44,17 @@ module Dentaku
       @disable_ast_cache = false
     end
 
-    def evaluate(expression, data={})
+    def evaluate(expression, data = {}, &block)
       evaluate!(expression, data)
-    rescue UnboundVariableError, Dentaku::ArgumentError
-      yield expression if block_given?
+    rescue UnboundVariableError, Dentaku::ArgumentError => ex
+      block.call(expression, ex) if block_given?
     end
 
-    def evaluate!(expression, data={})
+    def evaluate!(expression, data = {}, &block)
+      return expression.map { |e|
+        evaluate(e, data, &block)
+      } if expression.is_a? Array
+
       store(data) do
         node = expression
         node = ast(node) unless node.is_a?(AST::Node)
@@ -66,39 +76,50 @@ module Dentaku
     end
 
     def dependencies(expression)
+      if expression.is_a? Array
+        return expression.flat_map { |e| dependencies(e) }
+      end
       ast(expression).dependencies(memory)
     end
 
     def ast(expression)
       @ast_cache.fetch(expression) {
-        Parser.new(tokenizer.tokenize(expression), function_registry: @function_registry).parse.tap do |node|
+        options = {
+          case_sensitive: case_sensitive,
+          function_registry: @function_registry,
+          aliases: aliases
+        }
+
+        tokens = tokenizer.tokenize(expression, options)
+        Parser.new(tokens, options).parse.tap do |node|
           @ast_cache[expression] = node if cache_ast?
         end
       }
     end
 
-    def clear_cache(pattern=:all)
+    def clear_cache(pattern = :all)
       case pattern
       when :all
         @ast_cache = {}
       when String
         @ast_cache.delete(pattern)
       when Regexp
-        @ast_cache.delete_if { |k,_| k =~ pattern }
+        @ast_cache.delete_if { |k, _| k =~ pattern }
       else
         raise ::ArgumentError
       end
     end
 
-    def store(key_or_hash, value=nil)
+    def store(key_or_hash, value = nil)
       restore = Hash[memory]
 
       if value.nil?
-        _flat_hash(key_or_hash).each do |key, val|
-          memory[key.to_s.downcase] = val
+        key_or_hash = FlatHash.from_hash(key_or_hash) if nested_data_support
+        key_or_hash.each do |key, val|
+          memory[standardize_case(key.to_s)] = val
         end
       else
-        memory[key_or_hash.to_s.downcase] = value
+        memory[standardize_case(key_or_hash.to_s)] = value
       end
 
       if block_given?
@@ -131,16 +152,5 @@ 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/dependency_resolver.rb

@@ -10,7 +10,7 @@ module Dentaku
 
     def initialize(vars_to_dependencies_hash)
       # ensure variables are strings
-      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v]}]
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v] }]
     end
 
     def tsort_each_node(&block)

data/lib/dentaku/flat_hash.rb

@@ -0,0 +1,31 @@
+module Dentaku
+  class FlatHash
+    def self.from_hash(h, key = [], acc = {})
+      return acc.update(key => h)  unless h.is_a? Hash
+      h.each { |k, v| from_hash(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
+      end
+    end
+
+    def self.flatten_key(segments)
+      return segments.first if segments.length == 1
+      key = segments.join('.')
+      key = key.to_sym if segments.first.is_a?(Symbol)
+      key
+    end
+
+    def self.expand(h)
+      h.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] ||= {} }
+        child_hash[hash_levels.last] = v
+      end
+    end
+  end
+end

data/lib/dentaku/parser.rb

@@ -2,17 +2,18 @@ require_relative './ast'
 
 module Dentaku
   class Parser
-    attr_reader :input, :output, :operations, :arities
+    attr_reader :input, :output, :operations, :arities, :case_sensitive
 
-    def initialize(tokens, options={})
-      @input      = tokens.dup
-      @output     = []
+    def initialize(tokens, options = {})
+      @input             = tokens.dup
+      @output            = []
       @operations        = options.fetch(:operations, [])
       @arities           = options.fetch(:arities, [])
       @function_registry = options.fetch(:function_registry, nil)
+      @case_sensitive    = options.fetch(:case_sensitive, false)
     end
 
-    def consume(count=2)
+    def consume(count = 2)
       operator = operations.pop
       operator.peek(output)
 
@@ -45,7 +46,7 @@ module Dentaku
           output.push AST::String.new(token)
 
         when :identifier
-          output.push AST::Identifier.new(token)
+          output.push AST::Identifier.new(token, case_sensitive: case_sensitive)
 
         when :operator, :comparator, :combinator
           op_class = operation(token)

data/lib/dentaku/string_casing.rb

@@ -0,0 +1,7 @@
+module Dentaku
+  module StringCasing
+    def standardize_case(value)
+      case_sensitive ? value : value.downcase
+    end
+  end
+end

data/lib/dentaku/token.rb

@@ -2,7 +2,7 @@ module Dentaku
   class Token
     attr_reader :category, :raw_value, :value
 
-    def initialize(category, value, raw_value=nil)
+    def initialize(category, value, raw_value = nil)
       @category  = category
       @value     = value
       @raw_value = raw_value

data/lib/dentaku/token_matcher.rb

@@ -4,10 +4,10 @@ module Dentaku
   class TokenMatcher
     attr_reader :children, :categories, :values
 
-    def initialize(categories=nil, values=nil, children=[])
+    def initialize(categories = nil, values = nil, children = [])
       # store categories and values as hash to optimize key lookup, h/t @jan-mangs
-      @categories = [categories].compact.flatten.each_with_object({}) { |c,h| h[c] = 1 }
-      @values     = [values].compact.flatten.each_with_object({}) { |v,h| h[v] = 1 }
+      @categories = [categories].compact.flatten.each_with_object({}) { |c, h| h[c] = 1 }
+      @values     = [values].compact.flatten.each_with_object({}) { |v, h| h[v] = 1 }
       @children   = children.compact
       @invert     = false
 
@@ -29,7 +29,7 @@ module Dentaku
       leaf_matcher? ? matches_token?(token) : any_child_matches_token?(token)
     end
 
-    def match(token_stream, offset=0)
+    def match(token_stream, offset = 0)
       matched_tokens = []
       matched = false
 

data/lib/dentaku/token_scanner.rb

@@ -1,17 +1,20 @@
 require 'bigdecimal'
 require 'time'
+require 'dentaku/string_casing'
 require 'dentaku/token'
 
 module Dentaku
   class TokenScanner
-    def initialize(category, regexp, converter=nil, condition=nil)
+    extend StringCasing
+
+    def initialize(category, regexp, converter = nil, condition = nil)
       @category  = category
       @regexp    = %r{\A(#{ regexp })}i
       @converter = converter
       @condition = condition || ->(*) { true }
     end
 
-    def scan(string, last_token=nil)
+    def scan(string, last_token = nil)
       if (m = @regexp.match(string)) && @condition.call(last_token)
         value = raw = m.to_s
         value = @converter.call(raw) if @converter
@@ -25,6 +28,8 @@ module Dentaku
     end
 
     class << self
+      attr_reader :case_sensitive
+
       def available_scanners
         [
           :null,
@@ -62,10 +67,11 @@ module Dentaku
       end
 
       def scanners=(scanner_ids)
-        @scanners.select! { |k,v| scanner_ids.include?(k) }
+        @scanners.select! { |k, v| scanner_ids.include?(k) }
       end
 
-      def scanners
+      def scanners(options = {})
+        @case_sensitive = options.fetch(:case_sensitive, false)
         @scanners.values
       end
 
@@ -112,7 +118,9 @@ module Dentaku
       end
 
       def operator
-        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&' }.invert
+        names = {
+          pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%', bitor: '|', bitand: '&'
+        }.invert
         new(:operator, '\^|\+|-|\*|\/|%|\||&', lambda { |raw| names[raw] })
       end
 
@@ -152,12 +160,15 @@ module Dentaku
       def function
         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, '(')]
+          [
+            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| standardize_case(raw.strip) })
       end
     end