wongi-engine 0.0.1

data/lib/wongi-engine/dsl/dsl_extensions.rb

@@ -0,0 +1,43 @@
+module Wongi::Engine
+  module DSLExtensions
+
+    def self.create_extension extension
+
+      section = extension[:section]
+      clause = extension[:clause]
+      action = extension[:action]
+      body = extension[:body]
+      acceptor = extension[:accept]
+
+      define_method clause.first do |*args, &block|
+
+        raise "#{clause.first} can only be used in section #{section}, currently in #{@current_section}" if section != @current_section
+
+        if body
+
+          instance_exec *args, &body
+
+        elsif acceptor
+
+          accept acceptor.new( *args, &block )
+
+        elsif action
+
+          c = ExtensionClause.new *args, &block
+          c.name = clause.first
+          c.action = action
+          c.rule = self
+          accept c
+
+        end
+
+      end
+
+      clause[1..-1].each do |al|
+        alias_method al, clause.first
+      end
+
+    end
+
+  end
+end

data/lib/wongi-engine/dsl/extension_clause.rb

@@ -0,0 +1,36 @@
+module Wongi::Engine
+  class ExtensionClause
+
+    attr_accessor :name, :action, :rule
+
+    def initialize *args, &block
+      @args = args
+      @block = block
+    end
+
+    def import_into rete
+      if action.respond_to? :call
+        self
+      else
+        a = action.new *@args, &@block
+        a.name = name if a.respond_to? :name=
+        a.rule = rule if a.respond_to? :rule=
+        a.rete = rete if a.respond_to? :rete=
+        a
+      end
+    rescue Exception => e
+      e1 = Exception.new "error defining clause #{name} handled by #{action}: #{e}"
+      e1.set_backtrace e.backtrace
+      raise e1
+    end
+
+    def compile *args
+      action.call *args
+    end
+
+    def execute *args
+      action.call *args
+    end
+
+  end
+end

data/lib/wongi-engine/dsl/generation_clause.rb

@@ -0,0 +1,15 @@
+module Wongi::Engine
+  class GenerationClause
+
+    def initialize s, p, o
+      @triple = Template.new( s, p, o )
+    end
+
+    def import_into rete
+      generator = StatementGenerator.new @triple.import_into( rete )
+      generator.rete = rete
+      generator
+    end
+
+  end
+end

data/lib/wongi-engine/dsl/generic_production_rule.rb

@@ -0,0 +1,78 @@
+module Wongi::Engine
+  class GenericProductionRule
+
+    attr_reader :name
+    attr_reader :conditions, :actions
+
+    include DSLExtensions
+
+    class << self
+
+      def section s, *aliases
+        unless sections.include?(s)
+          sections << s
+          define_method s do |&d|
+            @current_section = s
+            instance_eval &d
+          end
+          aliases.each { |a| alias_method a, s }
+        end
+      end
+      
+      def sections
+        @sections ||= []
+      end
+
+    end
+
+    section :forall, :for_all
+    section :make, :do!
+
+    def initialize name
+      @name = name
+      @conditions = []
+      @actions = []
+      @current_section = nil
+      @acceptors = {}
+      GenericProductionRule.sections.each { |section| @acceptors[section] ||= [] }
+    end
+
+    def import_into rete
+
+      copy = self.class.new @name
+
+      copy.conditions = @acceptors[:forall].map do |condition|
+        if condition.respond_to? :import_into
+          condition.import_into(rete)
+        else
+          condition
+        end
+      end
+
+      copy.actions = @acceptors[:make].map do |action|
+        if action.respond_to? :import_into
+          action.import_into(rete)
+        else
+          action
+        end
+      end
+
+      copy
+    rescue Exception => e
+      e1 = Exception.new "in rule #{name}: #{e}"
+      e1.set_backtrace e.backtrace
+      raise e1
+    end
+
+    protected
+    attr_writer :conditions, :actions
+
+    def accept stuff
+      @acceptors[@current_section] << stuff
+    end
+
+
+  end
+
+
+end

data/lib/wongi-engine/dsl/ncc_production_rule.rb

@@ -0,0 +1,21 @@
+module Wongi::Engine
+  class NccProductionRule < GenericProductionRule
+
+    def initialize name = nil, &block
+      super
+      if block
+        forall &block
+      end
+    end
+
+    def import_into rete
+      NccSet.new @acceptors[:forall].map { |condition|
+        if condition.respond_to? :import_into
+          condition.import_into(rete)
+        else
+          condition
+        end
+      }
+    end
+  end
+end

data/lib/wongi-engine/dsl/production_rule.rb

@@ -0,0 +1,4 @@
+module Wongi::Engine
+  class ProductionRule < GenericProductionRule
+  end
+end

data/lib/wongi-engine/dsl/query.rb

@@ -0,0 +1,24 @@
+module Wongi::Engine
+
+  class Query < GenericProductionRule
+
+    attr_reader :parameters
+
+    def initialize name
+      super
+      @parameters = []
+    end
+
+    def search_on *terms
+      terms.each { |term| @parameters << term }
+    end
+
+    def import_into model
+      copy = super
+      copy.search_on *@parameters
+      copy
+    end
+
+  end
+
+end

data/lib/wongi-engine/graph.rb

@@ -0,0 +1,71 @@
+module Wongi::Engine
+
+  class Graph
+
+    def initialize rete
+      @rete = rete
+    end
+
+    def dot io, opts = { }
+
+      if String === io
+        File.open io, "w" do |actual_io|
+          dot actual_io
+        end
+        return
+      end
+
+      @io = io
+
+      @io.puts "digraph {"
+
+      dump_alphas(opts) unless opts[:alpha] == false
+      dump_betas(opts)
+
+      @io.puts "};"
+
+    ensure
+      @io = nil
+    end
+
+    private
+
+    def print_hash h
+      h.to_s.gsub /-/, '_'
+    end
+
+    def dump_alphas opts
+      @io.puts "subgraph cluster_alphas {"
+      @rete.alphas.select { |alpha| not alpha.betas.empty? }.each do |alpha|
+        @io.puts "node#{print_hash alpha.hash} [shape=box label=\"#{alpha.template.to_s.gsub /"/, "\\\""}\"];"
+      end
+      @io.puts "};"
+    end
+
+    def dump_betas opts
+      dump_beta @rete.beta_top, opts
+    end
+
+    def dump_beta beta, opts
+      @io.puts "node#{print_hash beta.hash} [label=\"#{beta.class.name.split('::').last}\"];"
+      if beta.parent
+        @io.puts "node#{print_hash beta.parent.hash} -> node#{print_hash beta.hash};"
+      end
+      if beta.is_a? NccNode
+        @io.puts "node#{print_hash beta.partner.hash} -> node#{print_hash beta.hash};"
+        @io.puts "{ rank=same; node#{print_hash beta.partner.hash} node#{print_hash beta.hash} }"
+      end
+      if beta.respond_to? :alpha and opts[:alpha] != false
+        alpha = beta.alpha
+        if alpha
+          @io.puts "node#{print_hash alpha.hash} -> node#{print_hash beta.hash};"
+        end
+      end
+      beta.children.each do |child|
+        dump_beta child, opts
+      end
+    end
+
+  end
+
+end

data/lib/wongi-engine/model_context.rb

@@ -0,0 +1,13 @@
+module Wongi
+  module Engine
+
+    class ModelContext
+      attr_reader :asserted_wmes, :retracted_wmes, :name
+      def initialize name
+        @name = name
+        @asserted_wmes = []
+        @retracted_wmes = []
+      end
+    end
+  end
+end

data/lib/wongi-engine/network.rb

@@ -0,0 +1,416 @@
+require 'wongi-engine/network/collectable'
+require 'wongi-engine/network/debug'
+
+module Wongi::Engine
+  class Network
+
+    attr_reader :alpha_top, :beta_top
+    attr_reader :queries, :results
+    attr_reader :productions
+
+    include NetworkParts::Collectable
+
+    protected
+    attr_accessor :alpha_hash
+    attr_writer :alpha_top, :beta_top
+    attr_writer :queries, :results
+
+    public
+
+    def debug!
+      extend NetworkParts::Debug
+    end
+
+    def initialize
+      @timeline = []
+      self.alpha_top = AlphaMemory.new( Template.new( :_, :_, :_ ), self )
+      self.alpha_hash = { Template.hash_for( :_, :_, :_ ) => self.alpha_top }
+      self.beta_top = BetaMemory.new(nil)
+      self.beta_top.rete = self
+      self.beta_top.seed
+      self.queries = {}
+      self.results = {}
+      @cache = {}
+      @revns = {}
+      @contexts = {}
+
+      @productions = { }
+
+      @collectors = {}
+      @collectors[:error] = []
+
+    end
+
+    def dump
+      beta_top.dump
+    end
+
+    def alphas
+      alpha_hash.values
+    end
+
+    def import thing
+      case thing
+      when String, Numeric, TrueClass, FalseClass, NilClass
+        thing
+      when Symbol
+        thing
+      else
+        raise "I don't know how to import a #{thing.class}"
+      end
+    end
+
+    def assert wme
+
+      unless wme.rete == self
+        wme = wme.import_into self
+      end
+
+      if @current_context
+        @current_context.asserted_wmes << wme
+        wme.context = @current_context
+      end
+
+      return if @cache.has_key?(wme)
+
+      # puts "ASSERTING #{wme}"
+      @cache[wme] = wme
+
+      s = wme.subject
+      p = wme.predicate
+      o = wme.object
+
+      alpha_activate(lookup( s,  p,  o), wme)
+      alpha_activate(lookup( s,  p, :_), wme)
+      alpha_activate(lookup( s, :_,  o), wme)
+      alpha_activate(lookup(:_,  p,  o), wme)
+      alpha_activate(lookup( s, :_, :_), wme)
+      alpha_activate(lookup(:_,  p, :_), wme)
+      alpha_activate(lookup(:_, :_,  o), wme)
+      alpha_activate(lookup(:_, :_, :_), wme)
+
+      wme
+    end
+
+    def wmes
+      alpha_top.wmes
+    end
+    alias_method :statements, :wmes
+    alias_method :facts, :wmes
+
+    def in_snapshot?
+      @in_snapshot
+    end
+
+    def snapshot!
+      @timeline.each_with_index do |slice, index|
+        source = if index == @timeline.size - 1
+          alpha_hash
+        else
+          @timeline[index+1]
+        end
+        # puts "source = #{source}"
+        wmes = {}
+        slice.each { |key, alpha| wmes[key] = alpha.wmes }
+        slice.each do |key, alpha|
+          in_snapshot {
+            wmes[key].dup.each { |wme| wme.destroy }
+          }
+          alpha.snapshot! source[key]
+        end
+      end
+    end
+
+    def rule name = nil, &block
+      r = ProductionRule.new( name || generate_rule_name )
+      r.instance_eval &block
+      self << r
+    end
+
+    def query name, &block
+      q = Query.new name
+      q.instance_eval &block
+      self << q
+    end
+
+    def << something
+      case something
+      when Array
+        if something.length == 3
+          assert WME.new( *something )
+        else
+          raise "Arrays must have 3 elements"
+        end
+      when ProductionRule
+        derived = something.import_into self
+        production = add_production derived.conditions, derived.actions
+        if something.name
+          productions[ something.name ] = production
+        end
+      when Query
+        derived = something.import_into self
+        prepare_query derived.name, derived.conditions, derived.parameters, derived.actions
+      when Ruleset
+        something.install self
+      when WME
+        assert something
+      #when Wongi::RDF::Document
+        #  something.statements.each do |st|
+        #    assert WME.new( st.subject, st.predicate, st.object, self )
+        #  end
+      when Rete
+        something.each do |st|
+          assert st.import_into( self )
+        end
+      else
+        raise "I don't know how to accept a #{something.class}"
+      end
+    end
+
+    def retract wme, is_real = false
+
+      if ! is_real
+        if @current_context
+          @current_context.retracted_wmes << wme
+        end
+      end
+
+      real = if is_real
+        wme
+      else
+        #find(wme.subject, wme.predicate, wme.object)
+        @cache[wme]
+      end
+
+      return false if real.nil?
+      @cache.delete(real)
+      raise "Cannot retract inferred statements" unless real.manual?
+
+      real.destroy
+
+      true
+
+    end
+
+    def compile_alpha condition
+      template = Template.new :_, :_, :_
+      time = condition.time
+
+      template.subject = condition.subject unless Template.variable?( condition.subject )
+      template.predicate = condition.predicate unless Template.variable?( condition.predicate )
+      template.object = condition.object unless Template.variable?( condition.object )
+
+      hash = template.hash
+      # puts "COMPILED CONDITION #{condition} WITH KEY #{key}"
+      if time == 0
+        return self.alpha_hash[ hash ] if self.alpha_hash.has_key?( hash )
+      else
+        return @timeline[time+1][ hash ] if @timeline[time+1] && @timeline[time+1].has_key?( hash )
+      end
+
+      alpha = AlphaMemory.new( template, self )
+
+      if time == 0
+        self.alpha_hash[ hash ] = alpha
+        initial_fill alpha
+      else
+        if @timeline[time+1].nil?
+          # => ensure lineage from 0 to time
+          compile_alpha condition.class.new(condition.subject, condition.predicate, condition.object, time + 1)
+          @timeline.unshift Hash.new
+        end
+        @timeline[time+1][ hash ] = alpha
+      end
+      alpha
+    end
+
+    def cache s, p, o
+      compile_alpha Template.new(s, p, o).import_into( self )
+    end
+
+    def initial_fill alpha
+      tpl = alpha.template
+      source = more_generic_alpha(tpl)
+      # puts "more efficient by #{alpha_top.wmes.size - source.wmes.size}" unless source ==
+      # alpha_top
+      source.wmes.each do |wme|
+        alpha.activate wme if wme =~ tpl
+      end
+    end
+
+    def add_production conditions, actions = []
+      real_add_production self.beta_top, conditions, [], actions, false
+    end
+
+    def remove_production pnode
+      delete_node_with_ancestors pnode
+    end
+
+    def prepare_query name, conditions, parameters, actions = []
+      query = self.queries[ name ] = BetaMemory.new( nil )
+      query.rete = self
+      transformed = {}
+      parameters.each { |param| transformed[param] = nil }
+      query.seed transformed
+      self.results[ name ] = real_add_production query, conditions, parameters, actions, true
+    end
+
+    def execute name, valuations
+      beta = self.queries[name]
+      raise "Undefined query #{name}; known queries are #{queries.keys}" unless beta
+      beta.subst valuations
+    end
+
+    def inspect
+      "<Rete>"
+    end
+
+    def context= name
+      if name && !@contexts.has_key?(name)
+        @current_context = (@contexts[name] ||= ModelContext.new name)
+      end
+    end
+
+    def retract_context name
+      return unless @contexts.has_key?(name)
+
+      if @current_context && @current_context.name == name
+        @current_context = nil
+      end
+      ctx = @contexts[name]
+      ctx.asserted_wmes.select { |wme| wme.generating_tokens.empty?  }.each { |wme| retract(wme, true) }
+      ctx.retracted_wmes.each { |wme| assert(wme) }
+      @contexts.delete name
+    end
+
+    def exists? wme
+      @cache[ wme ]
+    end
+
+    def each *args
+      return unless block_given?
+      unless args.length == 0 || args.length == 3
+        raise "Document#each expects a pattern or nothing at all"
+      end
+      s, p, o = if args.empty?
+        [:_, :_, :_]
+      else
+        args
+      end
+      no_check = s == :_ && p == :_ && o == :_
+      template = Template.new(s, p, o).import_into self
+      alpha_top.wmes.each do |wme|
+        yield wme if (no_check || wme =~ template)
+      end
+    end
+
+    def select s, p, o
+      template = Template.new(s, p, o).import_into self
+      matching = alpha_top.wmes.select { |wme| wme =~ template }
+      if block_given?
+        matching.each { |st| yield st.subject, st.predicate, st.object }
+      end
+      matching
+    end
+
+    def find s, p, o
+      template = Template.new(s, p, o).import_into self
+      source = best_alpha(template)
+      # puts "looking for #{template} among #{source.wmes.size} triples of #{source.template}"
+      source.wmes.detect { |wme| wme =~ template }
+    end
+
+    protected
+
+    def in_snapshot
+      @in_snapshot = true
+      yield
+    ensure
+      @in_snapshot = false
+    end
+
+    def generate_rule_name
+      "rule_#{productions.length}"
+    end
+
+    def lookup s, p, o
+      key = Template.hash_for(s, p, o)
+      # puts "Lookup for #{key}"
+      self.alpha_hash[ key ]
+    end
+
+    def alpha_activate alpha, wme
+      alpha.activate(wme) if alpha
+    end
+
+    def more_generic_alpha template
+      return alpha_top    # OPTIMISE => temporary; may use later or not use at all
+      return alpha_top if template.root?
+      more_generic_templates(template).reduce alpha_top do |best, template|
+        alpha = alpha_hash[template.hash]
+        if alpha && alpha.wmes.size < best.wmes.size
+          alpha
+        else
+          best
+        end
+      end
+    end
+
+    def more_generic_templates template
+      set = []
+      set << template.with_subject( :_ ) unless template.subject == :_
+      set << template.with_predicate( :_ ) unless template.predicate == :_
+      set << template.with_object( :_ ) unless template.object == :_
+      set.select { |item| not item.root? }
+    end
+
+    def best_alpha template
+      raise
+      candidates = alpha_hash.values.select do |alpha|
+        template =~ alpha.template
+      end
+      result = candidates.inject do |best, alpha|
+        if best.nil?
+          alpha
+        elsif alpha.wmes.length < best.wmes.length
+          alpha
+        else
+          best
+        end
+      end
+      puts "Best alpha for #{template} is #{result}"
+      result
+    end
+
+    def real_add_production root, conditions, parameters, actions, alpha_deaf
+      beta = root.network conditions, [], parameters, alpha_deaf
+
+      production = ProductionNode.new( beta, actions )
+      production.update_above
+      production
+    end
+
+    def delete_node_with_ancestors node
+
+      if node.kind_of?( NccNode )
+        delete_node_with_ancestors node.partner
+      end
+
+      if [BetaMemory, NegNode, NccNode, NccPartner].any? { | klass| node.kind_of? klass }
+        while node.tokens.first
+          node.tokens.first.delete
+        end
+      end
+
+      if node.parent
+        node.parent.children.delete node
+        if node.parent.children.empty?
+          delete_node_with_ancestors(node.parent)
+        end
+      end
+
+    end
+
+  end
+
+end