wongi-engine 0.0.1

data/lib/wongi-engine/network/collectable.rb

@@ -0,0 +1,42 @@
+module Wongi::Engine
+  module NetworkParts
+
+    module Collectable
+
+      def collectors name = nil
+        @collectors ||= { }
+        if name
+          @collectors[name] ||= [ ]
+        else
+          @collectors
+        end
+      end
+
+      def error_collectors
+        collectors :error
+      end
+
+      def add_collector collector, name
+        collectors( name ) << collector
+      end
+
+      def add_error_collector
+        add_collector collector, :error
+      end
+
+      def collection name
+        collectors( name ).map( &:default_collect ).flatten.uniq
+      end
+
+      def errors
+        error_collectors.map( &:errors ).flatten
+      end
+
+      def collected_tokens name
+        collectors( name ).map { |collector| collector.production.tokens }.flatten
+      end
+
+    end
+
+  end
+end

data/lib/wongi-engine/network/debug.rb

@@ -0,0 +1,25 @@
+module Wongi::Engine
+
+  module NetworkParts
+
+    module Debug
+
+      def full_wme_dump
+        @timeline.each_with_index do |slice, index|
+          puts "time #{ index - @timeline.length }"
+          slice.each do |key, alpha|
+            puts "\t#{alpha.template} -> [#{alpha.wmes.map(&:to_s).join ", "}]"
+          end
+          puts ""
+        end
+        puts "time 0"
+        alpha_hash.each do |key, alpha|
+          puts "\t#{alpha.template} -> [#{alpha.wmes.map(&:to_s).join ", "}]"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/wongi-engine/ruleset.rb

@@ -0,0 +1,74 @@
+module Wongi
+  module Engine
+    class Ruleset
+
+      class << self
+
+        def [] name
+          raise "undefined ruleset #{name}" unless rulesets.has_key?( name )
+          rulesets[ name ]
+        end
+
+        def register name, ruleset
+          raise "ruleset #{name} already exists" if rulesets.has_key?( name )
+          rulesets[ name ] = ruleset
+        end
+
+        def rulesets
+          @rulesets ||= {}
+        end
+
+        def reset
+          @rulesets = { }
+        end
+
+      end
+
+      def initialize name = nil
+        @rules = []
+        self.name( name ) if name
+      end
+
+      def inspect
+        "<Ruleset #{name}>"
+      end
+
+      def install rete
+        # puts "Installing ruleset #{name}"
+        @rules.each { |rule| rete << rule }
+      rescue Exception => e
+        e1 = Exception.new "error installing ruleset '#{name||'<unnamed>'}': #{e}"
+        e1.set_backtrace e.backtrace
+        raise e1
+      end
+
+      def name name = nil
+        if name && ! @name
+          self.class.register name, self
+          @name = name
+        end
+        @name
+      end
+
+      #    def uri uri = nil
+      #      @uri = uri if uri
+      #      @uri
+      #    end
+
+      def rule name, &definition
+        r = ProductionRule.new name
+        r.instance_eval &definition
+        @rules << r
+        r
+      end
+
+      def query name, &definition
+        r = Query.new name
+        r.instance_eval &definition
+        @rules << r
+        r
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/template.rb

@@ -0,0 +1,111 @@
+module Wongi::Engine
+
+  class Template < Struct.new( :subject, :predicate, :object, :time )
+
+    include CoreExt
+
+    attr_predicate debug: false
+
+    def self.variable? thing
+      Symbol === thing && thing =~ /^[A-Z]/
+    end
+
+    def initialize s = :_, p = :_, o = :_, time = 0
+      raise "Cannot work with continuous time" unless time.integer?
+      raise "Cannot look into the future" if time > 0
+      super
+    end
+
+    def import_into r
+      self.class.new r.import( subject ), r.import( predicate ), r.import( object ), time
+    end
+
+    def root?
+      subject == :_ && predicate == :_ && object == :_
+    end
+
+    def contains? var
+      self.class.variable?( var ) && array_form.include?( var )
+    end
+
+    def hash
+      @hash ||= array_form.map( &:hash ).hash
+    end
+
+    def self.hash_for *args
+      args.map( &:hash ).hash
+    end
+
+    def === wme
+      wme =~ self if WME === wme
+    end
+
+    def == other
+      return false unless Template === other
+      subject == other.subject && predicate == other.predicate && object == other.object
+    end
+
+    def =~ template
+      case template
+      when Template
+        ( template.subject == :_ || template.subject == subject ) &&
+        ( template.predicate == :_ || template.predicate == predicate ) &&
+        ( template.object == :_ || template.object == object )
+      else
+        raise "Templates can only match templates"
+      end
+    end
+
+
+    def compile context
+      tests, assignment = *JoinNode.compile( self, context.earlier, context.parameters )
+      alpha = context.rete.compile_alpha( self )
+      context.node = context.node.beta_memory.join_node( alpha, tests, assignment, context.alpha_deaf )
+      context.earlier << self
+      context
+    end
+
+    def inspect
+      "<~ #{subject.inspect} #{predicate.inspect} #{object.inspect} #{time}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    private
+
+    def array_form
+      @array_form ||= [ subject, predicate, object ]
+    end
+
+  end
+
+  class NegTemplate < Template
+    # :arg: context => Wongi::Rete::BetaNode::CompilationContext
+    def compile context
+      tests, _ = *JoinNode.compile( self, context.earlier, context.parameters )
+      alpha = context.rete.compile_alpha( self )
+      context.node = context.node.neg_node( alpha, tests, context.alpha_deaf )
+      context.node.debug = debug?
+      context.earlier << self
+      context
+    end
+  end
+
+  class OptionalTemplate < Template
+
+    def compile context
+      tests, assignment = *JoinNode.compile( self, context.earlier, context.parameters )
+      alpha = context.rete.compile_alpha( self )
+      context.node = context.node.beta_memory.optional_node( alpha, tests, assignment, context.alpha_deaf )
+      context.node.debug = debug?
+      context.earlier << self
+      context
+    end
+
+  end
+
+
+
+end

data/lib/wongi-engine/token.rb

@@ -0,0 +1,137 @@
+module Wongi::Engine
+
+  class Token
+
+    include CoreExt
+
+    attr_reader :parent, :wme, :children
+    attr_accessor :node, :owner
+    attr_reader :neg_join_results
+    attr_reader :opt_join_results
+    attr_reader :ncc_results
+    attr_reader :generated_wmes
+    attr_predicate :has_optional
+
+    def initialize token, wme, assignments
+      @parent, @wme, @assignments = token, wme, assignments
+      @children = []
+      @neg_join_results = []
+      @opt_join_results = []
+      @ncc_results = []
+      @generated_wmes = []
+      @deexecutors = []
+      token.children << self if token
+      wme.tokens << self if wme
+    end
+
+    def subst variable, value
+      @cached_assignments = nil
+      if @assignments.has_key? variable
+        @assignments[ variable ] = value
+      end
+    end
+
+    def assignments
+      @cached_assignments ||= all_assignments
+    end
+
+    def [] var
+      assignments[ var ]
+    end
+
+    def to_s
+      str = "TOKEN [\n"
+      all_assignments.each_pair { |key, value| str << "\t#{key} => #{value}\n" }
+      str << "]"
+      str
+    end
+
+    def wmes
+      if parent
+        parent.wmes + [wme]
+      else
+        [wme]
+      end
+    end
+
+    def delete preserve_self = false
+      delete_children
+      # => TODO: why was this last check needed? consult the Rete PhD
+      @node.tokens.delete self unless preserve_self# or @node.kind_of?( NccPartner )
+      @wme.tokens.delete self if @wme
+      @parent.children.delete self if @parent
+
+      retract_generated
+      deexecute
+
+      case @node
+      when NegNode
+        @neg_join_results.each do |njr|
+          njr.wme.neg_join_results.delete njr if njr.wme
+        end
+        @neg_join_results = []
+
+      when OptionalNode
+        @opt_join_results.each do |ojr|
+          ojr.wme.opt_join_results.delete ojr
+        end
+        @opt_join_results = []
+
+      when NccNode
+        @ncc_results.each do |nccr|
+          nccr.wme.tokens.delete nccr
+          nccr.parent.children.delete nccr
+        end
+        @ncc_results = []
+
+      when NccPartner
+        @owner.ncc_results.delete self
+        if @owner.ncc_results.empty?
+          @node.ncc.children.each do |node|
+            node.left_activate @owner, nil, {}
+          end
+        end
+      end
+
+    end
+
+    def delete_children
+      while @children.first
+        @children.first.delete
+      end
+    end
+
+    protected
+
+
+    def retract_generated
+
+      @generated_wmes.each do |wme|
+        unless wme.manual?  # => TODO: does this ever fail at all?
+          wme.generating_tokens.delete self
+          if wme.generating_tokens.empty?
+            wme.rete.retract wme, true
+          end
+        end
+      end
+      @generated_wmes = []
+
+    end
+
+    def deexecute
+      @deexecutors.each { |deexec| deexec.deexecute self }
+      @deexecutors = []
+    end
+
+    def all_assignments
+      raise "Assignments is not a hash" unless @assignments.kind_of?( Hash )
+      if @parent
+        @parent.assignments.merge @assignments
+      else
+        @assignments
+      end
+    end
+
+  end
+
+end

data/lib/wongi-engine/version.rb

@@ -0,0 +1,5 @@
+module Wongi
+  module Engine
+    VERSION = "0.0.1"
+  end
+end

data/lib/wongi-engine/wme.rb

@@ -0,0 +1,134 @@
+module Wongi::Engine
+
+  class WME < Struct.new( :subject, :predicate, :object )
+
+    attr_reader :rete
+
+    attr_reader :alphas, :tokens, :generating_tokens
+    attr_reader :neg_join_results, :opt_join_results
+
+    def initialize s, p, o, r = nil
+
+      @alphas = []
+      @tokens = []
+      @generating_tokens = []
+      @neg_join_results = []
+      @opt_join_results = []
+
+      @rete = r
+
+      if r
+        super( r.import(s), r.import(p), r.import(o) )
+      else
+        super( s, p, o )
+      end
+
+    end
+
+    def import_into r
+      self.class.new subject, predicate, object, r
+    end
+
+    def dup
+      self.class.new subject, predicate, object, rete
+    end
+
+    def == other
+      subject == other.subject && predicate == other.predicate && object == other.object
+    end
+
+    def =~ template
+      raise "Cannot match a WME against a #{template.class}" unless Template === template
+      result = match_member( template, :subject ) & match_member( template, :predicate ) & match_member( template, :object )
+      if result.match?
+        result
+      end
+    end
+
+    def manual?
+      generating_tokens.empty?
+    end
+
+    def generated?
+      !manual?
+    end
+
+    def destroy
+
+      alphas.each { |alpha| alpha.remove self }.clear
+      while tokens.first
+        tokens.first.delete self    # => will remove itself from the array
+      end
+
+      destroy_neg_join_results
+      destroy_opt_join_results
+
+    end
+
+    def inspect
+      "<WME #{subject.inspect} #{predicate.inspect} #{object.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def hash
+      @hash ||= array_form.map( &:hash ).hash
+    end
+
+    protected
+
+    def array_form
+      @array_form ||= [ subject, predicate, object ]
+    end
+
+    def destroy_neg_join_results
+      neg_join_results.each do |njr|
+
+        token = njr.owner
+        results = token.neg_join_results
+        results.delete njr
+
+        if results.empty? && !rete.in_snapshot?
+          token.node.children.each { |beta|
+            beta.left_activate token, nil, { }
+          }
+        end
+
+      end.clear
+    end
+
+    def destroy_opt_join_results
+      opt_join_results.each do |ojr|
+
+        token = ojr.owner
+        results = token.opt_join_results
+        results.delete ojr
+
+        if results.empty?
+          token.delete_children
+          token.node.children.each { |beta|
+            beta.left_activate token
+          }
+        end
+
+      end.clear
+    end
+
+    def match_member template, member
+      result = WMEMatchData.new
+      mine = self.send member
+      theirs = template.send member
+      if theirs == :_ || mine == theirs
+        result.match!
+      elsif Template.variable? theirs
+        result.match!
+        result[theirs] = mine
+      end
+      result
+    end
+
+  end
+
+end