mort666-wongi-engine 0.2.9

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,85 @@
+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
+
+      def full_dump io = $stdout
+
+        alpha_hash.each_value do |alpha|
+          io.puts "ALPHA #{alpha.template}"
+          alpha.wmes.each do |wme|
+            dump_wme wme, io
+          end
+        end
+        dump_beta beta_top, io
+
+      end
+
+      private
+
+      def token_lineage token
+        result = []
+        while token.parent
+          result << token.parent
+          token = token.parent
+        end
+        result
+      end
+
+      def dump_wme wme, io
+        io.puts "\tWME: #{wme.object_id} #{wme}"
+        wme.tokens.each { |token| io.puts "\t\tTOKEN #{token.object_id}" }
+        io.puts "\tGENERATING:" unless wme.generating_tokens.empty?
+        wme.generating_tokens.each { |token| io.puts "\t\tTOKEN #{token.object_id}" }
+      end
+
+      def dump_beta beta, io
+        case beta
+        when BetaMemory
+          dump_beta_memory beta, io
+        when NccNode
+          dump_ncc beta, io
+        else
+          io.puts "BETA #{beta.object_id} #{beta.class} : TODO"
+
+        end
+        io.puts "\tCHILDREN: #{beta.children.map(&:object_id).join ", "}"
+        beta.children.each { |child| dump_beta child, io } unless beta.children.empty?
+      end
+
+      def dump_beta_memory beta, io
+        io.puts "BETA MEMORY #{beta.object_id}"
+        beta.tokens.each { |token|
+          io.puts "\tTOKEN #{token.object_id} [#{token_lineage(token).map(&:object_id).map(&:to_s).join(" - ")}]"
+          token.wmes.each { |wme| io.puts "\t\tWME " + wme.object_id.to_s }
+        }
+      end
+
+      def dump_ncc beta, io
+        io.puts "NCC #{beta.object_id}"
+        beta.tokens.each { |token|
+          io.puts "\tTOKEN #{token.object_id} [#{token_lineage(token).map(&:object_id).map(&:to_s).join(" - ")}]"
+          token.wmes.each { |wme| io.puts "\t\tWME " + wme.object_id.to_s }
+        }
+      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 Error, "undefined ruleset #{name}" unless rulesets.has_key?( name )
+          rulesets[ name ]
+        end
+
+        def register name, ruleset
+          raise Error, "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 StandardError => e
+        e1 = Error.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 = DSL::Rule.new name
+        r.instance_eval &definition
+        @rules << r
+        r
+      end
+
+      def query name, &definition
+        r = DSL::Query.new name
+        r.instance_eval &definition
+        @rules << r
+        r
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/template.rb

@@ -0,0 +1,78 @@
+module Wongi::Engine
+
+  Template = Struct.new( :subject, :predicate, :object ) do
+
+    def self.variable? thing
+      return false unless thing.is_a?(Symbol)
+      thing[0] >= 'A' && thing[0] <= 'Z'
+    end
+
+    # TODO: reintroduce Network#import when bringing back RDF support
+
+    def root?
+      subject == :_ && predicate == :_ && object == :_
+    end
+
+    def variables
+      [].tap do |a|
+        a << subject if Template.variable?( subject )
+        a << predicate if Template.variable?( predicate )
+        a << object if Template.variable?( object )
+      end
+    end
+
+    def hash
+      @hash ||= [subject.hash, predicate.hash, object.hash].hash
+    end
+
+    def self.hash_for *args
+      args.map( &:hash ).hash
+    end
+
+    def == other
+      other.is_a?(Template) && 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 Error, "templates can only match other templates"
+      end
+    end
+
+    def inspect
+      "<~#{subject.inspect} #{predicate.inspect} #{object.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def resolve!(token)
+      s = if Template.variable?(subject)
+        raise DefinitionError, "unbound variable #{subject} in token #{token}" unless token.has_var?(subject)
+        token[subject]
+      else
+        subject
+      end
+      p = if Template.variable?(predicate)
+        raise DefinitionError, "unbound variable #{predicate} in token #{token}" unless token.has_var?(predicate)
+        token[predicate]
+      else
+        predicate
+      end
+      o = if Template.variable?(object)
+        raise DefinitionError, "unbound variable #{object} in token #{token}" unless token.has_var?(object)
+        token[object]
+      else
+        object
+      end
+      [s, p, o]
+    end
+
+  end
+end

data/lib/wongi-engine/token.rb

@@ -0,0 +1,114 @@
+module Wongi::Engine
+
+  class Token
+
+    include CoreExt
+
+    attr_reader :children
+    attr_reader :wme
+    attr_reader :node
+    attr_reader :overlay
+    attr_accessor :owner, :parent
+    attr_reader :neg_join_results
+    attr_reader :opt_join_results
+    attr_reader :ncc_results
+    attr_reader :generated_wmes
+    attr_predicate :optional
+    attr_predicate :deleted
+
+    def initialize node, token, wme, assignments
+      @node, @parent, @wme, @assignments = node, token, wme, assignments
+      @overlay = wme ? wme.overlay.highest(token.overlay) : (token ? token.overlay : node.rete.default_overlay)
+      @children = []
+      @deleted = false
+      @neg_join_results = []
+      @opt_join_results = []
+      @ncc_results = []
+      @generated_wmes = []
+      token.children << self if token
+    end
+
+    def ancestors
+      if parent
+        parent.ancestors.unshift parent
+      else
+        []
+      end
+    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
+      if a = assignments[ var ]
+        a.respond_to?(:call) ? a.call( self ) : a
+      end
+    end
+
+    def has_var? x
+      assignments.has_key? x
+    end
+
+    # TODO ignore assignments?
+    def duplicate? other
+      self.parent.equal?(other.parent) && @wme.equal?(other.wme) && self.assignments == other.assignments
+    end
+
+    def to_s
+      str = "TOKEN [ #{object_id} parent=#{parent ? parent.object_id : 'nil'} "
+      all_assignments.each_pair { |key, value| str << "#{key} => #{value} " }
+      str << "]"
+      str
+    end
+
+    def destroy
+      deleted!
+    end
+
+    def dispose!
+      parent.children.delete(self) if parent
+      neg_join_results.dup.each(&:unlink)
+      opt_join_results.dup.each(&:unlink)
+      @parent = nil
+      @wme = nil
+    end
+
+    # for neg feedback loop protection
+    def generated? wme
+      return true if generated_wmes.any? { |w| w == wme }
+      return children.any? { |t| t.generated? wme }
+    end
+
+    protected
+
+    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
+
+  class FakeToken < Token
+    def initialize token, wme, assignments
+      @parent, @wme, @assignments = token, wme, assignments
+      @children = []
+      @neg_join_results = []
+      @opt_join_results = []
+      @ncc_results = []
+      @generated_wmes = []
+    end
+  end
+
+end

data/lib/wongi-engine/version.rb

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

data/lib/wongi-engine/wme.rb

@@ -0,0 +1,89 @@
+module Wongi::Engine
+
+  WME = Struct.new( :subject, :predicate, :object ) do
+
+    include CoreExt
+
+    attr_reader :rete
+
+    attr_reader :generating_tokens
+    attr_reader :neg_join_results, :opt_join_results
+    attr_accessor :overlay
+    attr_predicate :deleted
+    attr_predicate :manual
+
+    def initialize s, p, o, r = nil
+
+      manual!
+
+      @deleted = false
+      @alphas = []
+      @generating_tokens = []
+      @neg_join_results = []
+      @opt_join_results = []
+
+      @rete = r
+
+    # TODO: reintroduce Network#import when bringing back RDF support
+      super( s, p, o )
+
+    end
+
+    def import_into r
+      self.class.new( subject, predicate, object, r ).tap do |wme|
+        wme.overlay = overlay
+        wme.manual = self.manual?
+      end
+    end
+
+    def dup
+      self.class.new( subject, predicate, object, rete ).tap do |wme|
+        wme.overlay = overlay
+        wme.manual = self.manual?
+      end
+    end
+
+    def == other
+      subject == other.subject && predicate == other.predicate && object == other.object
+    end
+
+    def =~ template
+      raise Wongi::Engine::Error, "Cannot match a WME against a #{template.class}" unless Template === template
+      result = match_member( self.subject, template.subject ) & match_member( self.predicate, template.predicate ) & match_member( self.object, template.object )
+      if result.match?
+        result
+      end
+    end
+
+    def generated?
+      !generating_tokens.empty?
+    end
+
+    def inspect
+      "{#{subject.inspect} #{predicate.inspect} #{object.inspect}}"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def hash
+      @hash ||= [subject.hash, predicate.hash, object.hash].hash
+    end
+
+    protected
+
+    def match_member mine, theirs
+      result = WMEMatchData.new
+      if theirs == :_ || mine == theirs
+        result.match!
+      elsif Template.variable? theirs
+        result.match!
+        result[theirs] = mine
+      end
+      result
+    end
+
+  end
+
+end