wongi-engine 0.0.17 → 0.1.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ab2c246ebcf7d3a4a381b39195f950b72f9ac22
-  data.tar.gz: 0378728b15e4a72274333ba56ac78e16c67bdb36
+  metadata.gz: a090dea5a39943ac1d887178b7d1b9a5df3f618c
+  data.tar.gz: ceca588238658bf643d067e3502643e554719ef5
 SHA512:
-  metadata.gz: 66819b8d5b0165c204e091debcc4de62b1f7a03d4067fdc6d966bd2b17fb0d7196f08244cfa33c7426399caef75929bf6157abe8407170d908dd9009b4d2acb0
-  data.tar.gz: 414beb220fd40675deff5563a1c8b59a79ed644e0ef1c688c3ce559f00c239e5516c39bc1a06ec44d95da7503ba56f1a5131be5fa4dfcc207ba2a3d7d0fa3a82
+  metadata.gz: cb3fc2402bcdfe4afbd0b0f5bf72aba18b32f40a89c013c429f0507414f7f243962f42dff3aa31bf412a5345f449eb6d13b152fc9f6120efacd2cade85b4290d
+  data.tar.gz: 39063e5d6c69a37bd3b10a52badf24666d79c0d887a110f528e3b94b498a5e21273c702e4c8e80f024e0b6d1d6723c8cdb91ab9cb200a4c56ad35b487580ffcf

data/.hgtags

@@ -0,0 +1 @@
+b1dfd471a2a9e4a57f0e4932ac184faa5d6fa5b5 v0.1.0.alpha1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Valeri Sokolov <ulfurinn@ulfurinn.net>
+Copyright (c) 2012-2015 Valeri Sokolov <ulfurinn@ulfurinn.net>
 
 MIT License
 

data/lib/wongi-engine/alpha_memory.rb

@@ -21,11 +21,11 @@ module Wongi::Engine
       end
     end
 
-    def remove wme
+    def deactivate wme
       @wmes.delete wme
-      # we don't need to unlink ourselves from the wme
-      # because this is only called from WME#destroy
-      # so the wme will take care of it itself
+      betas.each do |beta|
+        beta.alpha_deactivate wme
+      end
     end
 
     def snapshot! alpha

data/lib/wongi-engine/beta/assignment_node.rb

@@ -23,14 +23,29 @@ module Wongi::Engine
     end
 
     def beta_activate token, wme = nil, assignments = { }
-      propagate_activation token, nil, { @variable => @body }
+      children.each do |child|
+        child.beta_activate Token.new( child, token, nil, { @variable => @body } )
+      end
+    end
+
+    def beta_deactivate token
+      children.each do |child|
+        child.tokens.each do |t|
+          if t.parent == token
+            child.beta_deactivate t
+            #token.destroy
+          end
+        end
+      end
     end
 
     def refresh_child child
       tmp = children
       self.children = [ child ]
       parent.tokens.each do |token|
-        beta_activate token
+        children.each do |child|
+          child.beta_activate Token.new( child, token, nil, { @variable => @body } )
+        end
       end
       self.children = tmp
     end

data/lib/wongi-engine/beta/beta_memory.rb

@@ -14,16 +14,14 @@ module Wongi::Engine
 
     def seed assignments = {}
       @seed = assignments
-      t = Token.new( nil, nil, assignments )
-      t.node = self
+      t = Token.new( self, nil, nil, assignments )
       @tokens << t
     end
 
     def subst valuations
       @tokens.first.destroy
 
-      token = Token.new( nil, nil, @seed )
-      token.node = self
+      token = Token.new( self, nil, nil, @seed )
       @tokens << token
 
       valuations.each { |variable, value| token.subst variable, value }
@@ -32,40 +30,38 @@ module Wongi::Engine
       end
     end
 
-    def beta_activate token, wme, assignments
-      dp "MEMORY beta-activated with #{wme} #{wme.object_id}"
-      existing = @tokens.reject(&:deleted?).find { |et| et.duplicate? token, wme, assignments }
-      if existing
-        t = existing
-      else
-        t = Token.new( token, wme, assignments)
-        t.node = self
-        @tokens << t
+    def beta_activate token
+      existing = @tokens.reject(&:deleted?).find { |et| et.duplicate? token }
+      return if existing # TODO really?
+      @tokens << token
+      children.each do |child|
+        child.beta_activate token
       end
-      self.children.each do |child|
-        if child.kind_of? BetaMemory
-          child.beta_activate t, nil, {}
-        else
-          child.beta_activate t
-        end
+      token
+    end
+
+    def beta_deactivate token
+      return nil unless tokens.find token
+      @tokens.delete token
+      token.deleted!
+      if token.parent
+        token.parent.children.delete token # should this go into Token#destroy?
+      end
+      children.each do |child|
+        child.beta_deactivate token
       end
-      t
+      token
     end
 
     def refresh_child child
       tokens.each do |token|
-        case child
-        when BetaMemory, NegNode
-          child.beta_activate token, nil, {}
-        else
-          child.beta_activate token
-        end
+        child.beta_activate token
       end
     end
 
-    def delete_token token
-      @tokens.delete token
-    end
+    # def delete_token token
+    #   @tokens.delete token
+    # end
 
     # => TODO: investigate if we really need this
     #def beta_memory

data/lib/wongi-engine/beta/beta_node.rb

@@ -34,6 +34,13 @@ module Wongi::Engine
       end
     end
 
+    abstract :alpha_activate
+    abstract :alpha_deactivate
+    abstract :alpha_reactivate
+    abstract :beta_activate
+    abstract :beta_deactivate
+    abstract :beta_reactivate
+
     def beta_memory
       beta = children.find { |node| BetaMemory === node }
       if beta.nil?
@@ -44,11 +51,11 @@ module Wongi::Engine
       beta
     end
 
-    def join_node alpha, tests, assignment, filters, alpha_deaf
-      existing = children.find{ |node| JoinNode === node && node.equivalent?( alpha, tests, assignment, filters ) }
+    def join_node alpha, tests, assignment, alpha_deaf
+      existing = children.find{ |node| JoinNode === node && node.equivalent?( alpha, tests, assignment ) }
       return existing if existing
 
-      node = JoinNode.new self, tests, assignment, filters
+      node = JoinNode.new self, tests, assignment
       node.alpha = alpha
       alpha.betas << node unless alpha_deaf
 
@@ -56,8 +63,7 @@ module Wongi::Engine
     end
 
     def optional_node alpha, tests, assignment, alpha_deaf
-      node = OptionalNode.new self, tests, assignment
-      node.alpha = alpha
+      node = OptionalNode.new self, alpha, tests, assignment
       alpha.betas << node unless alpha_deaf
       node
     end
@@ -147,12 +153,6 @@ module Wongi::Engine
 
     private
 
-    def propagate_activation token, wme, assignments
-      self.children.each do |child|
-        child.beta_activate token, wme, assignments
-      end
-    end
-
     def dp message
       if debug?
         puts "#{indent}#{message}"

data/lib/wongi-engine/beta/filter_node.rb

@@ -10,9 +10,22 @@ module Wongi
         self.test = test
       end
 
-      def beta_activate token, wme = nil, assignments = { }
+      def beta_activate token
         if test.passes? token
-          propagate_activation token, nil, {}
+          children.each do |child|
+            child.beta_activate Token.new( child, token, nil, {} )
+          end
+        end
+      end
+
+      def beta_deactivate token
+        children.each do |child|
+          child.tokens.each do |t|
+            if t.parent == token
+              child.beta_deactivate t
+              #token.destroy
+            end
+          end
         end
       end
 

data/lib/wongi-engine/beta/join_node.rb

@@ -5,6 +5,9 @@ module Wongi
       def call token = nil
         wme.send field
       end
+      def inspect
+        "subject of #{wme}"
+      end
     end
 
     class BetaTest
@@ -34,16 +37,14 @@ module Wongi
       attr_accessor :alpha
       attr_reader :tests
       attr_reader :assignment_pattern
-      attr_reader :filters
 
-      def initialize parent, tests, assignment, filters
+      def initialize parent, tests, assignment
         super(parent)
         @tests = tests
         @assignment_pattern = assignment
-        @filters = filters
       end
 
-      def equivalent? alpha, tests, assignment_pattern, filters
+      def equivalent? alpha, tests, assignment_pattern
         return false unless self.alpha == alpha
         return false unless self.assignment_pattern == assignment_pattern
         return false unless (self.tests.empty? && tests.empty?) || self.tests.length == tests.length && self.tests.all? { |my_test|
@@ -51,25 +52,27 @@ module Wongi
             my_test.equivalent? new_test
           }
         }
-        return false unless (self.filters.empty? && filters.empty?) || self.filters.length == filters.length && self.filters.all? { |my_filter|
-          filters.include? my_filter
-        }
         true
       end
 
-      def alpha= a
-        @alpha = a
-        # puts "\talpha = #{alpha}"
+      def alpha_activate wme
+        assignments = collect_assignments( wme )
+        parent.tokens.each do |token|
+          if matches?( token, wme )
+            children.each do |beta|
+              beta.beta_activate Token.new( beta, token, wme, assignments )
+            end
+          end
+        end
       end
 
-      def alpha_activate wme
-        dp "JOIN alpha-activated with #{wme}"
-        collected = collect_assignments( wme )
-        self.parent.tokens.each do |token|
-          dp "-MATCHING #{token}"
-          if matches?( token, wme ) && passes_filters?( token, wme, collected )
-            dp "-JOIN MATCHED, PROPAGATING"
-            propagate_activation token, wme, collected
+      def alpha_deactivate wme
+        children.each do |child|
+          child.tokens.each do |token|
+            if token.wme == wme
+              child.beta_deactivate token
+              #token.destroy
+            end
           end
         end
       end
@@ -78,23 +81,38 @@ module Wongi
         dp "JOIN beta-activated"
         self.alpha.wmes.each do |wme|
           dp "-TESTING WME #{wme}"
-          collected = collect_assignments( wme )
-          if matches?( token, wme ) && passes_filters?( token, wme, collected )
+          assignments = collect_assignments( wme )
+          if matches?( token, wme )
             dp "-WME MATCHED, PROPAGATING"
-            propagate_activation token, wme, collected
+            children.each do |beta|
+              beta.beta_activate Token.new( beta, token, wme, assignments )
+            end
           else
             dp "-NO MATCH"
           end
         end
       end
 
+      def beta_deactivate token
+        children.each do |child|
+          child.tokens.each do |t|
+            if t.parent == token
+              child.beta_deactivate t
+              #token.destroy
+            end
+          end
+        end
+      end
+
       def refresh_child child
-        tmp = children
-        self.children = [ child ]
         alpha.wmes.each do |wme|
-          alpha_activate wme
+          assignments = collect_assignments( wme )
+          parent.tokens.each do |token|
+            if matches?( token, wme )
+              child.beta_activate Token.new( child, token, wme, assignments )
+            end
+          end
         end
-        self.children = tmp
       end
 
       def self.compile condition, earlier, parameters
@@ -136,11 +154,6 @@ module Wongi
         true
       end
 
-      def passes_filters? token, wme, assignments
-        t = FakeToken.new token, wme, assignments
-        @filters.all? { |filter| filter.passes? t }
-      end
-
       def collect_assignments wme
         assignments = {}
         return assignments if self.assignment_pattern.nil?

data/lib/wongi-engine/beta/ncc_node.rb

@@ -26,13 +26,10 @@ module Wongi
         @tokens = []
       end
 
-      #  def beta_activate token, wme, assignments
-      #    t = Token.new token, wme, assignments
-      #    t.node = self
-      def beta_activate token, wme = nil, assignments = { } # => FIXME: beta_activate has different signatures for storing and non-storing nodes...
-        t = Token.new token, nil, {}
-        t.node = self
-        tokens << t
+      def beta_activate token
+        return if @tokens.find { |t| t.parent == token }
+        t = Token.new self, token, nil, {}
+        @tokens << t
         partner.tokens.each do |ncc_token|
           next unless ncc_token.ancestors.find { |a| a.equal? token }
           t.ncc_results << ncc_token
@@ -40,7 +37,40 @@ module Wongi
         end
         if t.ncc_results.empty?
           children.each do |child|
-            child.beta_activate t, nil, {}
+            child.beta_activate Token.new( child, t, nil, { } )
+          end
+        end
+      end
+
+      def beta_deactivate token
+        t = @tokens.find { |tok| tok.parent == token }
+        return unless @tokens.delete t
+        t.deleted!
+        partner.tokens.select { |ncc| ncc.owner == t }.each do |ncc_token|
+          ncc_token.owner = nil
+          t.ncc_results.delete ncc_token
+        end
+        children.each do |beta|
+          beta.tokens.select { |token| token.parent == t }.each do |token|
+            beta.beta_deactivate token
+          end
+        end
+      end
+
+      def ncc_activate token
+        token.deleted = false
+        @tokens << token unless @tokens.include?( token )
+        children.each do |child|
+          child.beta_activate Token.new( child, token, nil, { } )
+        end
+      end
+
+      def ncc_deactivate token
+        return unless @tokens.delete token
+        token.deleted!
+        children.each do |beta|
+          beta.tokens.select { |t| t.parent == token }.each do |t|
+            beta.beta_deactivate t
           end
         end
       end
@@ -48,19 +78,19 @@ module Wongi
       def refresh_child child
         tokens.each do |token|
           if token.ncc_results.empty?
-            child.beta_activate token, nil, {}
+            child.beta_activate Token.new( child, t, nil, { } )
           end
         end
       end
 
-      def delete_token token
-        tokens.delete token
-        token.ncc_results.each do |nccr|
-          nccr.wme.tokens.delete( nccr ) if nccr.wme
-          nccr.parent.children.delete nccr
-        end
-        token.ncc_results.clear
-      end
+      # def delete_token token
+      #   tokens.delete token
+      #   token.ncc_results.each do |nccr|
+      #     nccr.wme.tokens.delete( nccr ) if nccr.wme
+      #     nccr.parent.children.delete nccr
+      #   end
+      #   token.ncc_results.clear
+      # end
 
     end
   end

data/lib/wongi-engine/beta/ncc_partner.rb

@@ -14,31 +14,41 @@ module Wongi
       end
 
       def beta_activate token
-        t = Token.new token, nil, {}
-        t.node = self
-        # owner = ncc.tokens.find do |ncc_token|
-        #   ncc_token.parent.node == divergent
-        # end
-        divergent_token = t.ancestors.find { |a| a.node == divergent }
-        owner = ncc.tokens.find { |o| o.parent == divergent_token }
+        t = Token.new self, token, nil, {}
+        owner = owner_for( t )
+        tokens << t
         if owner
           owner.ncc_results << t
           t.owner = owner
-          owner.delete_children
-        else
-          tokens << t
+          owner.node.ncc_deactivate owner
         end
       end
 
-      def delete_token token
+      def beta_deactivate t
+        token = tokens.find { |tok| tok.parent == t }
+        return unless token
         token.owner.ncc_results.delete token
         if token.owner.ncc_results.empty?
-          ncc.children.each do |node|
-            node.beta_activate token.owner, nil, {}
-          end
+          ncc.ncc_activate token.owner
         end
+      end
+
+      private
 
+      def owner_for token
+        divergent_token = token.ancestors.find { |t| t.node == divergent }
+        ncc.tokens.find { |t| t.ancestors.include? divergent_token }
       end
+
+      # def delete_token token
+      #   token.owner.ncc_results.delete token
+      #   if token.owner.ncc_results.empty?
+      #     ncc.children.each do |node|
+      #       node.beta_activate token.owner, nil, {}
+      #     end
+      #   end
+
+      # end
     end
   end
 end

data/lib/wongi-engine/beta/neg_node.rb

@@ -1,11 +1,16 @@
 module Wongi
   module Engine
 
-    NegJoinResult = Struct.new :owner, :wme
+    NegJoinResult = Struct.new :token, :wme do
+      def unlink
+        wme.neg_join_results.delete self
+        token.neg_join_results.delete self
+      end
+    end
 
     class NegNode < BetaNode
 
-      attr_reader :tokens, :alpha, :tests
+      attr_reader :alpha, :tests
 
       def initialize parent, tests, alpha, unsafe
         super(parent)
@@ -18,36 +23,71 @@ module Wongi
           if matches?( token, wme ) && ( @unsafe || ! token.generated?( wme ) )# feedback loop protection
             # order matters for proper invalidation
             make_join_result(token, wme)
-            token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
+            #token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
+            children.each do |child|
+              child.tokens.each do |t|
+                if t.parent == token
+                  child.beta_deactivate t
+                  #token.destroy
+                end
+              end
+            end
           end
         end
       end
 
-      def beta_activate token, newwme, assignments
-        existing = @tokens.find { |et| et.duplicate? token, newwme, assignments }
-        if existing
-          t = existing
-        else
-          t = Token.new( token, newwme, assignments)
-          t.node = self
-          @tokens << t
+      def alpha_deactivate wme
+        wme.neg_join_results.dup.each do |njr|
+          safe_tokens.each do |token|
+            next unless token == njr.token
+            njr.unlink
+            if token.neg_join_results.empty?
+              children.each do |child|
+                child.beta_activate Token.new( child, token, nil, {} )
+              end
+            end
+          end
         end
+      end
+
+      def beta_activate token
+        return if @tokens.find { |et| et.duplicate? token }
+        @tokens << token
         alpha.wmes.each do |wme|
-          if matches?( t, wme )
-            make_join_result(t, wme)
+          if matches?( token, wme )
+            make_join_result(token, wme)
           end
         end
-        if t.neg_join_results.empty?
-          self.children.each do |child|
-            child.beta_activate t, nil, {}
+        if token.neg_join_results.empty?
+          children.each do |child|
+            child.beta_activate Token.new( child, token, nil, {} )
           end
         end
       end
 
+      def beta_deactivate token
+        return nil unless tokens.find token
+        @tokens.delete token
+        token.deleted!
+        if token.parent
+          token.parent.children.delete token # should this go into Token#destroy?
+        end
+        token.neg_join_results.each &:unlink
+        children.each do |child|
+          child.tokens.each do |t|
+            if t.parent == token
+              child.beta_deactivate t
+              #token.destroy
+            end
+          end
+        end
+        token
+      end
+
       def refresh_child child
         safe_tokens.each do |token|
           if token.neg_join_results.empty?
-            child.beta_activate token, nil, {}
+            child.beta_activate Token.new( child, token, nil, {} )
           end
         end
         alpha.wmes.each do |wme|
@@ -55,13 +95,13 @@ module Wongi
         end
       end
 
-      def delete_token token
-        tokens.delete token
-        token.neg_join_results.each do |njr|
-          njr.wme.neg_join_results.delete njr if njr.wme
-        end
-        token.neg_join_results.clear
-      end
+      # def delete_token token
+      #   tokens.delete token
+      #   token.neg_join_results.each do |njr|
+      #     njr.wme.neg_join_results.delete njr if njr.wme
+      #   end
+      #   token.neg_join_results.clear
+      # end
 
       protected