dentaku 1.2.6 → 2.0.0

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:max, ->(*args) {
+  args.max
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:min, ->(*args) {
+  args.min
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:not, ->(logical) {
+  ! logical
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:round, ->(numeric, places=nil) {
+  numeric.round(places || 0)
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:rounddown, ->(numeric) {
+  numeric.floor
+})

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

@@ -0,0 +1,5 @@
+require_relative '../function'
+
+Dentaku::AST::Function.register(:roundup, ->(numeric) {
+  numeric.ceil
+})

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

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

data/lib/dentaku/ast/grouping.rb

@@ -0,0 +1,13 @@
+module Dentaku
+  module AST
+    class Grouping
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context)
+      end
+    end
+  end
+end

data/lib/dentaku/ast/identifier.rb

@@ -0,0 +1,29 @@
+require_relative '../exceptions'
+
+module Dentaku
+  module AST
+    class Identifier < Node
+      attr_reader :identifier
+
+      def initialize(token)
+        @identifier = token.value.downcase
+      end
+
+      def value(context={})
+        v = context[identifier]
+        case v
+        when Node
+          v.value
+        when NilClass
+          raise UnboundVariableError.new([identifier])
+        else
+          v
+        end
+      end
+
+      def dependencies(context={})
+        context.has_key?(identifier) ? [] : [identifier]
+      end
+    end
+  end
+end

data/lib/dentaku/ast/multiplication.rb

@@ -0,0 +1,15 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Multiplication < Operation
+      def value(context={})
+        left.value(context) * right.value(context)
+      end
+
+      def self.precedence
+        20
+      end
+    end
+  end
+end

data/lib/dentaku/ast/negation.rb

@@ -0,0 +1,25 @@
+module Dentaku
+  module AST
+    class Negation < Operation
+      def initialize(node)
+        @node = node
+      end
+
+      def value(context={})
+        @node.value(context) * -1
+      end
+
+      def self.arity
+        1
+      end
+
+      def self.right_associative?
+        true
+      end
+
+      def self.precedence
+        40
+      end
+    end
+  end
+end

data/lib/dentaku/ast/nil.rb

@@ -0,0 +1,9 @@
+module Dentaku
+  module AST
+    class Nil < Node
+      def value(*)
+        nil
+      end
+    end
+  end
+end

data/lib/dentaku/ast/node.rb

@@ -0,0 +1,13 @@
+module Dentaku
+  module AST
+    class Node
+      def self.precedence
+        0
+      end
+
+      def self.arity
+        nil
+      end
+    end
+  end
+end

data/lib/dentaku/ast/numeric.rb

@@ -0,0 +1,17 @@
+module Dentaku
+  module AST
+    class Numeric < Node
+      def initialize(token)
+        @value = token.value
+      end
+
+      def value(*)
+        @value
+      end
+
+      def dependencies(*)
+        []
+      end
+    end
+  end
+end

data/lib/dentaku/ast/operation.rb

@@ -0,0 +1,20 @@
+module Dentaku
+  module AST
+    class Operation < Node
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left  = left
+        @right = right
+      end
+
+      def dependencies(context={})
+        (left.dependencies(context) + right.dependencies(context)).uniq
+      end
+
+      def self.right_associative?
+        false
+      end
+    end
+  end
+end

data/lib/dentaku/ast/string.rb

@@ -0,0 +1,17 @@
+module Dentaku
+  module AST
+    class String < Node
+      def initialize(token)
+        @value = token.value
+      end
+
+      def value(*)
+        @value
+      end
+
+      def dependencies(*)
+        []
+      end
+    end
+  end
+end

data/lib/dentaku/ast/subtraction.rb

@@ -0,0 +1,15 @@
+require_relative './operation'
+
+module Dentaku
+  module AST
+    class Subtraction < Operation
+      def value(context={})
+        left.value(context) - right.value(context)
+      end
+
+      def self.precedence
+        10
+      end
+    end
+  end
+end

data/lib/dentaku/bulk_expression_solver.rb

@@ -1,13 +1,14 @@
 require 'dentaku/calculator'
 require 'dentaku/dependency_resolver'
 require 'dentaku/exceptions'
-require 'dentaku/expression'
+require 'dentaku/parser'
+require 'dentaku/tokenizer'
 
 module Dentaku
   class BulkExpressionSolver
     def initialize(expression_hash, memory)
       self.expression_hash = expression_hash
-      self.memory = memory
+      self.calculator = Calculator.new.store(memory)
     end
 
     def solve!
@@ -25,7 +26,7 @@ module Dentaku
 
     private
 
-    attr_accessor :expression_hash, :memory
+    attr_accessor :expression_hash, :calculator
 
     def return_undefined_handler
       ->(*) { :undefined }
@@ -38,7 +39,7 @@ module Dentaku
     def load_results(&block)
       variables_in_resolve_order.each_with_object({}) do |var_name, r|
         begin
-          r[var_name] = evaluate!(expressions[var_name], r)
+          r[var_name] = calculator.memory[var_name] || evaluate!(expressions[var_name], r)
         rescue Dentaku::UnboundVariableError, ZeroDivisionError => ex
           r[var_name] = block.call(ex)
         end
@@ -46,7 +47,7 @@ module Dentaku
     end
 
     def dependencies(expression)
-      Expression.new(expression, memory).identifiers
+      Parser.new(Tokenizer.new.tokenize(expression)).parse.dependencies
     end
 
     def expressions
@@ -63,13 +64,7 @@ module Dentaku
     end
 
     def evaluate!(expression, results)
-      expr = Expression.new(expression, memory.merge(expressions))
-      raise UnboundVariableError.new(expr.identifiers) if expr.unbound?
       calculator.evaluate!(expression, results)
     end
-
-    def calculator
-      @calculator ||= Calculator.new.store(memory)
-    end
   end
 end

data/lib/dentaku/calculator.rb

@@ -1,27 +1,26 @@
 require 'dentaku/bulk_expression_solver'
-require 'dentaku/evaluator'
 require 'dentaku/exceptions'
-require 'dentaku/expression'
-require 'dentaku/rule_set'
 require 'dentaku/token'
 require 'dentaku/dependency_resolver'
+require 'dentaku/parser'
 
 module Dentaku
   class Calculator
-    attr_reader :result, :rule_set
+    attr_reader :result, :memory, :tokenizer
 
     def initialize
       clear
-      @rule_set = RuleSet.new
+      @tokenizer = Tokenizer.new
+      @ast_cache = {}
     end
 
-    def add_function(fn)
-      rule_set.add_function(fn)
+    def add_function(name, body)
+      Dentaku::AST::Function.register(name, body)
       self
     end
 
     def add_functions(fns)
-      fns.each { |fn| add_function(fn) }
+      fns.each { |(name, body)| add_function(name, body) }
       self
     end
 
@@ -32,35 +31,42 @@ module Dentaku
     end
 
     def evaluate!(expression, data={})
-      store(data) do
-        expr = Expression.new(expression, @memory)
-        raise UnboundVariableError.new(expr.identifiers) if expr.unbound?
-        @evaluator ||= Evaluator.new(rule_set)
-        @result = @evaluator.evaluate(expr.tokens)
+      memory[expression] || store(data) do
+        node = expression
+        node = ast(node) unless node.is_a?(AST::Node)
+        node.value(memory)
       end
     end
 
     def solve!(expression_hash)
-      BulkExpressionSolver.new(expression_hash, @memory).solve!
+      BulkExpressionSolver.new(expression_hash, memory).solve!
     end
 
     def solve(expression_hash, &block)
-      BulkExpressionSolver.new(expression_hash, @memory).solve(&block)
+      BulkExpressionSolver.new(expression_hash, memory).solve(&block)
     end
 
     def dependencies(expression)
-      Expression.new(expression, @memory).identifiers
+      ast(expression).dependencies(memory)
+    end
+
+    def ast(expression)
+      @ast_cache.fetch(expression) {
+        Parser.new(tokenizer.tokenize(expression)).parse.tap do |node|
+          @ast_cache[expression] = node if Dentaku.cache_ast?
+        end
+      }
     end
 
     def store(key_or_hash, value=nil)
-      restore = @memory.dup
+      restore = memory.dup
 
       if value.nil?
         key_or_hash.each do |key, val|
-          @memory[key.downcase.to_s] = val
+          memory[key.downcase.to_s] = val
         end
       else
-        @memory[key_or_hash.to_s] = value
+        memory[key_or_hash.to_s] = value
       end
 
       if block_given?
@@ -78,7 +84,7 @@ module Dentaku
     end
 
     def empty?
-      @memory.empty?
+      memory.empty?
     end
   end
 end

data/lib/dentaku/parser.rb

@@ -0,0 +1,131 @@
+require_relative './ast'
+
+module Dentaku
+  class Parser
+    attr_reader :input, :output, :operations, :arities
+
+    def initialize(tokens)
+      @input      = tokens.dup
+      @output     = []
+      @operations = []
+      @arities    = []
+    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))
+    end
+
+    def parse
+      return AST::Nil.new if input.empty?
+
+      while token = input.shift
+        case token.category
+        when :numeric
+          output.push AST::Numeric.new(token)
+
+        when :string
+          output.push AST::String.new(token)
+
+        when :identifier
+          output.push AST::Identifier.new(token)
+
+        when :operator, :comparator, :combinator
+          op_class = operation(token)
+
+          if op_class.right_associative?
+            while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
+              consume
+            end
+
+            operations.push op_class
+          else
+            while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
+              consume
+            end
+
+            operations.push op_class
+          end
+
+        when :function
+          arities.push 0
+          operations.push function(token)
+
+        when :grouping
+          case token.value
+          when :open, :fopen
+            if input.first && input.first.value == :close
+              input.shift
+              consume(0)
+            else
+              operations.push AST::Grouping
+            end
+
+          when :close
+            while operations.any? && operations.last != AST::Grouping
+              consume
+            end
+
+            lparen = operations.pop
+            fail "Unbalanced parenthesis" unless lparen == AST::Grouping
+
+            if operations.last && operations.last < AST::Function
+              consume(arities.pop.succ)
+            end
+
+          when :comma
+            arities[-1] += 1
+            while operations.any? && operations.last != AST::Grouping
+              consume
+            end
+
+          else
+            fail "Unknown grouping token #{ token.value }"
+          end
+
+        else
+          fail "Not implemented for tokens of category #{ token.category }"
+        end
+      end
+
+      while operations.any?
+        consume
+      end
+
+      unless output.count == 1
+        fail "Parse error"
+      end
+
+      output.first
+    end
+
+    def operation(token)
+      {
+        add:      AST::Addition,
+        subtract: AST::Subtraction,
+        multiply: AST::Multiplication,
+        divide:   AST::Division,
+        pow:      AST::Exponentiation,
+        negate:   AST::Negation,
+
+        lt:       AST::LessThan,
+        gt:       AST::GreaterThan,
+        le:       AST::LessThanOrEqual,
+        ge:       AST::GreaterThanOrEqual,
+        ne:       AST::NotEqual,
+        eq:       AST::Equal,
+
+        and:      AST::And,
+        or:       AST::Or,
+      }.fetch(token.value)
+    end
+
+    def function(token)
+      Dentaku::AST::Function.get(token.value)
+    end
+  end
+end