dentaku 2.0.11 → 3.0.0

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

@@ -1,7 +1,8 @@
 require_relative '../function'
 
-Dentaku::AST::Function.register(:roundup, :numeric, ->(numeric, precision=0) {
+Dentaku::AST::Function.register(:roundup, :numeric, lambda { |numeric, precision = 0|
+  precision = precision.to_i
   tens = 10.0**precision
-  result = (numeric * tens).ceil / tens
+  result = (Dentaku::AST::Function.numeric(numeric) * tens).ceil / tens
   precision <= 0 ? result.to_i : result
 })

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

@@ -1,8 +1,8 @@
 # import all functions from Ruby's Math module
-require_relative "../function"
+require_relative '../function'
 
 Math.methods(false).each do |method|
-  Dentaku::AST::Function.register(method, :numeric, ->(*args) {
-    Math.send(method, *args)
+  Dentaku::AST::Function.register(method, :numeric, lambda { |*args|
+    Math.send(method, *args.map { |arg| Dentaku::AST::Function.numeric(arg) })
   })
 end

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

@@ -0,0 +1,8 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:switch, :logical, lambda { |*args|
+  value = args.shift
+  default = args.pop if args.size.odd?
+  match = args.find_index.each_with_index { |arg, index| index.even? && arg == value }
+  match ? args[match + 1] : default
+})

data/lib/dentaku/ast/identifier.rb

@@ -11,7 +11,8 @@ module Dentaku
 
       def value(context={})
         v = context.fetch(identifier) do
-          raise UnboundVariableError.new([identifier])
+          raise UnboundVariableError.new([identifier]),
+                "no value provided for variables: #{identifier}"
         end
 
         case v
@@ -23,7 +24,7 @@ module Dentaku
       end
 
       def dependencies(context={})
-        context.has_key?(identifier) ? dependencies_of(context[identifier]) : [identifier]
+        context.key?(identifier) ? dependencies_of(context[identifier]) : [identifier]
       end
 
       private

data/lib/dentaku/ast/negation.rb

@@ -3,7 +3,11 @@ module Dentaku
     class Negation < Arithmetic
       def initialize(node)
         @node = node
-        fail ParseError, "Negation requires numeric operand" unless valid_node?(node)
+
+        unless valid_node?(node)
+          raise NodeError.new(:numeric, left.type, :left),
+                "#{self.class} requires numeric operands"
+        end
       end
 
       def operator

data/lib/dentaku/ast/node.rb

@@ -9,6 +9,9 @@ module Dentaku
         nil
       end
 
+      def self.peek(*)
+      end
+
       def dependencies(context={})
         []
       end

data/lib/dentaku/bulk_expression_solver.rb

@@ -1,4 +1,3 @@
-require 'dentaku/calculator'
 require 'dentaku/dependency_resolver'
 require 'dentaku/exceptions'
 require 'dentaku/parser'
@@ -55,7 +54,7 @@ module Dentaku
             evaluate!(expressions[var_name], expressions.merge(r))
 
           r[var_name] = value
-        rescue Dentaku::UnboundVariableError, ZeroDivisionError => ex
+        rescue UnboundVariableError, Dentaku::ZeroDivisionError => ex
           ex.recipient_variable = var_name
           r[var_name] = block.call(ex)
         end

data/lib/dentaku/calculator.rb

@@ -21,10 +21,6 @@ module Dentaku
       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)
       @function_registry.register(name, type, body)
       self
@@ -44,7 +40,7 @@ module Dentaku
 
     def evaluate(expression, data={})
       evaluate!(expression, data)
-    rescue UnboundVariableError, ArgumentError
+    rescue UnboundVariableError, Dentaku::ArgumentError
       yield expression if block_given?
     end
 
@@ -52,6 +48,11 @@ module Dentaku
       store(data) do
         node = expression
         node = ast(node) unless node.is_a?(AST::Node)
+        unbound = node.dependencies - memory.keys
+        unless unbound.empty?
+          raise UnboundVariableError.new(unbound),
+                "no value provided for variables: #{unbound.join(', ')}"
+        end
         node.value(memory)
       end
     end
@@ -85,7 +86,7 @@ module Dentaku
       when Regexp
         @ast_cache.delete_if { |k,_| k =~ pattern }
       else
-        fail Dentaku::ArgumentError
+        raise ::ArgumentError
       end
     end
 

data/lib/dentaku/exceptions.rb

@@ -6,17 +6,91 @@ module Dentaku
 
     def initialize(unbound_variables)
       @unbound_variables = unbound_variables
-      super("no value provided for variables: #{ unbound_variables.join(', ') }")
+    end
+  end
+
+  class NodeError < StandardError
+    attr_reader :child, :expect, :actual
+
+    def initialize(expect, actual, child)
+      @expect = Array(expect)
+      @actual = actual
+      @child = child
     end
   end
 
   class ParseError < StandardError
+    attr_reader :reason, :meta
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      node_invalid too_few_operands undefined_function
+      unprocessed_token unknown_case_token unbalanced_bracket
+      unbalanced_parenthesis unknown_grouping_token not_implemented_token_category
+      invalid_statement
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new reason, meta
+    end
   end
 
   class TokenizerError < StandardError
+    attr_reader :reason, :meta
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      parse_error too_many_opening_parentheses too_many_closing_parentheses
+      unexpected_zero_width_match
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new reason, meta
+    end
   end
 
   class ArgumentError < ::ArgumentError
+    attr_reader :reason, :meta
+
+    def initialize(reason, **meta)
+      @reason = reason
+      @meta = meta
+    end
+
+    private_class_method :new
+
+    VALID_REASONS = %i[
+      invalid_operator invalid_value too_few_arguments
+      too_much_arguments incompatible_type
+    ].freeze
+
+    def self.for(reason, **meta)
+      unless VALID_REASONS.include?(reason)
+        raise ::ArgumentError, "Unhandled #{reason}"
+      end
+
+      new reason, meta
+    end
   end
 
   class ZeroDivisionError < ::ZeroDivisionError

data/lib/dentaku/parser.rb

@@ -12,13 +12,19 @@ module Dentaku
       @function_registry = options.fetch(:function_registry, nil)
     end
 
-    def get_args(count)
-      Array.new(count) { output.pop }.reverse
-    end
-
     def consume(count=2)
       operator = operations.pop
-      output.push operator.new(*get_args(operator.arity || count))
+      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
+      end
+      args = Array.new(args_size) { output.pop }.reverse
+
+      output.push operator.new(*args)
+    rescue NodeError => e
+      fail! :node_invalid, operator: operator, child: e.child, expect: e.expect, actual: e.actual
     end
 
     def parse
@@ -62,8 +68,13 @@ module Dentaku
           output.push AST::Nil.new
 
         when :function
+          func = function(token)
+          if func.nil?
+            fail! :undefined_function, function_name: token.value
+          end
+
           arities.push 0
-          operations.push function(token)
+          operations.push func
 
         when :case
           case token.value
@@ -118,7 +129,7 @@ module Dentaku
             end
 
             unless operations.count == 1 && operations.last == AST::Case
-              fail ParseError, "Unprocessed token #{ token.value }"
+              fail! :unprocessed_token, token_name: token.value
             end
             consume(arities.pop.succ)
           when :when
@@ -155,7 +166,22 @@ module Dentaku
 
             operations.push(AST::CaseElse)
           else
-            fail ParseError, "Unknown case token #{ token.value }"
+            fail! :unknown_case_token, token_name: token.value
+          end
+
+        when :access
+          case token.value
+          when :lbracket
+            operations.push AST::Access
+          when :rbracket
+            while operations.any? && operations.last != AST::Access
+              consume
+            end
+
+            unless operations.last == AST::Access
+              fail! :unbalanced_bracket, token
+            end
+            consume
           end
 
         when :grouping
@@ -163,6 +189,7 @@ module Dentaku
           when :open
             if input.first && input.first.value == :close
               input.shift
+              arities.pop
               consume(0)
             else
               operations.push AST::Grouping
@@ -174,7 +201,9 @@ module Dentaku
             end
 
             lparen = operations.pop
-            fail ParseError, "Unbalanced parenthesis" unless lparen == AST::Grouping
+            unless lparen == AST::Grouping
+              fail! :unbalanced_parenthesis, token
+            end
 
             if operations.last && operations.last < AST::Function
               consume(arities.pop.succ)
@@ -187,11 +216,11 @@ module Dentaku
             end
 
           else
-            fail ParseError, "Unknown grouping token #{ token.value }"
+            fail! :unknown_grouping_token, token_name: token.value
           end
 
         else
-          fail ParseError, "Not implemented for tokens of category #{ token.category }"
+          fail! :not_implemented_token_category, token_category: token.category
         end
       end
 
@@ -200,7 +229,7 @@ module Dentaku
       end
 
       unless output.count == 1
-        fail ParseError, "Invalid statement"
+        fail! :invalid_statement
       end
 
       output.first
@@ -237,5 +266,37 @@ module Dentaku
     def function_registry
       @function_registry ||= Dentaku::AST::FunctionRegistry.new
     end
+
+    private
+
+    def fail!(reason, **meta)
+      message =
+        case reason
+        when :node_invalid
+          "#{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 :undefined_function
+          "Undefined function #{meta.fetch(:function_name)}"
+        when :unprocessed_token
+          "Unprocessed token #{meta.fetch(:token_name)}"
+        when :unknown_case_token
+          "Unknown case token #{meta.fetch(:token_name)}"
+        when :unbalanced_bracket
+          "Unbalanced bracket"
+        when :unbalanced_parenthesis
+          "Unbalanced parenthesis"
+        when :unknown_grouping_token
+          "Unknown grouping token #{meta.fetch(:token_name)}"
+        when :not_implemented_token_category
+          "Not implemented for tokens of category #{meta.fetch(:token_category)}"
+        when :invalid_statement
+          "Invalid statement"
+        else
+          raise ::ArgumentError, "Unhandled #{reason}"
+        end
+
+      raise ParseError.for(reason, meta), message
+    end
   end
 end

data/lib/dentaku/token.rb

@@ -16,6 +16,10 @@ module Dentaku
       raw_value.to_s.length
     end
 
+    def empty?
+      length.zero?
+    end
+
     def grouping?
       is?(:grouping)
     end

data/lib/dentaku/token_scanner.rb

@@ -31,14 +31,16 @@ module Dentaku
           :whitespace,
           :datetime, # before numeric so it can pick up timestamps
           :numeric,
+          :hexadecimal,
           :double_quoted_string,
           :single_quoted_string,
           :negate,
+          :combinator,
           :operator,
           :grouping,
+          :access,
           :case_statement,
           :comparator,
-          :combinator,
           :boolean,
           :function,
           :identifier
@@ -81,7 +83,13 @@ module Dentaku
       end
 
       def numeric
-        new(:numeric, '(\d+(\.\d+)?|\.\d+)\b', lambda { |raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
+        new(:numeric, '((?:\d+(\.\d+)?|\.\d+)(?:(e|E)(\+|-)?\d+)?)\b', lambda { |raw|
+          raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i
+        })
+      end
+
+      def hexadecimal
+        new(:numeric, '(0x[0-9a-f]+)\b', lambda { |raw| raw[2..-1].to_i(16) })
       end
 
       def double_quoted_string
@@ -113,6 +121,11 @@ module Dentaku
         new(:grouping, '\(|\)|,', lambda { |raw| names[raw] })
       end
 
+      def access
+        names = { lbracket: '[', rbracket: ']' }.invert
+        new(:access, '\[|\]', lambda { |raw| names[raw] })
+      end
+
       def case_statement
         names = { open: 'case', close: 'end', then: 'then', when: 'when', else: 'else' }.invert
         new(:case, '(case|end|then|when|else)\b', lambda { |raw| names[raw.downcase] })
@@ -125,7 +138,11 @@ module Dentaku
       end
 
       def combinator
-        new(:combinator, '(and|or)\b', lambda { |raw| raw.strip.downcase.to_sym })
+        names = { and: '&&', or: '||' }.invert
+        new(:combinator, '(and|or|&&|\|\|)\s', lambda { |raw|
+          norm = raw.strip.downcase
+          names.fetch(norm) { norm.to_sym }
+        })
       end
 
       def boolean

data/lib/dentaku/tokenizer.rb

@@ -13,13 +13,17 @@ module Dentaku
       input    = strip_comments(string.to_s.dup)
 
       until input.empty?
-        fail TokenizerError, "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|
+        scanned = TokenScanner.scanners.any? do |scanner|
           scanned, input = scan(input, scanner)
           scanned
         end
+
+        unless scanned
+          fail! :parse_error, at: input
+        end
       end
 
-      fail TokenizerError, "too many opening parentheses" if @nesting > 0
+      fail! :too_many_opening_parentheses if @nesting > 0
 
       @tokens
     end
@@ -31,11 +35,14 @@ module Dentaku
     def scan(string, scanner)
       if tokens = scanner.scan(string, last_token)
         tokens.each do |token|
-          fail TokenizerError, "unexpected zero-width match (:#{ token.category }) at '#{ string }'" if token.length == 0
+          if token.empty?
+            fail! :unexpected_zero_width_match,
+                  token_category: token.category, at: string
+          end
 
           @nesting += 1 if LPAREN == token
           @nesting -= 1 if RPAREN == token
-          fail TokenizerError, "too many closing parentheses" if @nesting < 0
+          fail! :too_many_closing_parentheses if @nesting < 0
 
           @tokens << token unless token.is?(:whitespace)
         end
@@ -50,5 +57,25 @@ module Dentaku
     def strip_comments(input)
       input.gsub(/\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//, '')
     end
+
+    private
+
+    def fail!(reason, **meta)
+      message =
+        case reason
+        when :parse_error
+          "parse error at: '#{meta.fetch(:at)}'"
+        when :too_many_opening_parentheses
+          "too many opening parentheses"
+        when :too_many_closing_parentheses
+          "too many closing parentheses"
+        when :unexpected_zero_width_match
+          "unexpected zero-width match (:#{meta.fetch(:category)}) at '#{meta.fetch(:at)}'"
+        else
+          raise ::ArgumentError, "Unhandled #{reason}"
+        end
+
+      raise TokenizerError.for(reason, meta), message
+    end
   end
 end