wongi-engine 0.0.2 → 0.0.3

data/lib/wongi-engine/beta.rb

@@ -1,6 +1,7 @@
 require 'wongi-engine/beta/beta_node'
 require 'wongi-engine/beta/beta_memory'
 require 'wongi-engine/beta/filter_node'
+require 'wongi-engine/beta/assignment_node'
 require 'wongi-engine/beta/join_node'
 require 'wongi-engine/beta/ncc_partner'
 require 'wongi-engine/beta/ncc_node'

data/lib/wongi-engine/dsl.rb

@@ -55,7 +55,7 @@ dsl {
   accept Wongi::Engine::NccProductionRule
 
   clause :any
-  action Wongi::Engine::AnyRule
+  accept Wongi::Engine::AnyRule
 
   clause :maybe, :optional
   accept Wongi::Engine::OptionalTemplate
@@ -66,6 +66,12 @@ dsl {
   clause :diff, :ne
   accept Wongi::Engine::InequalityTest
 
+  clause :assert, :dynamic
+  accept Wongi::Engine::AssertingTest
+
+  clause :assign, :introduce
+  accept Wongi::Engine::Assignment
+
   clause :asserted, :added
   body { |s, p, o|
     missing s, p, o, -1

data/lib/wongi-engine/filter/asserting_test.rb

@@ -0,0 +1,20 @@
+module Wongi::Engine
+
+  class AssertingTest < FilterTest
+
+    def initialize *vars, &body
+      @vars = vars
+      @body = body
+    end
+
+    def passes? token
+      if @vars.empty?
+        @body.call token
+      else
+        @body.call *( @vars.map { |var| token[var] } )
+      end
+    end
+
+  end
+
+end

data/lib/wongi-engine/filter/equality_test.rb

@@ -0,0 +1,36 @@
+module Wongi::Engine
+
+  class EqualityTest < FilterTest
+
+    attr_reader :x, :y
+
+    def initialize x, y
+      @x, @y = x, y
+    end
+
+    def passes? token
+
+      x = if Template.variable? @x
+        token[@x]
+      else
+        @x
+      end
+
+      y = if Template.variable? @y
+        token[@y]
+      else
+        @y
+      end
+
+      return false if x == :_ || y == :_
+      return x == y
+
+    end
+
+    def == other
+      super && x == other.x && y == other.y
+    end
+
+  end
+
+end

data/lib/wongi-engine/filter/filter_test.rb

@@ -0,0 +1,21 @@
+module Wongi::Engine
+
+  class FilterTest
+
+    def passes? token
+      raise "#{self.class} must implement #passes?"
+    end
+
+    def compile context
+      context.node = context.node.beta_memory.filter_node( self )
+      context.earlier << self
+      context
+    end
+
+    def == other
+      self.class == other.class
+    end
+
+  end
+
+end

data/lib/wongi-engine/filter/inequality_test.rb

@@ -0,0 +1,36 @@
+module Wongi::Engine
+
+  class InequalityTest < FilterTest
+
+    attr_reader :x, :y
+
+    def initialize x, y
+      @x, @y = x, y
+    end
+
+    def passes? token
+
+      x = if Template.variable? @x
+        token[@x]
+      else
+        @x
+      end
+
+      y = if Template.variable? @y
+        token[@y]
+      else
+        @y
+      end
+
+      return false if x == :_ || y == :_
+      return x != y
+
+    end
+
+    def == other
+      super && x == other.x && y == other.y
+    end
+
+  end
+
+end

data/lib/wongi-engine/filter.rb

@@ -0,0 +1,4 @@
+require 'wongi-engine/filter/filter_test'
+require 'wongi-engine/filter/equality_test'
+require 'wongi-engine/filter/inequality_test'
+require 'wongi-engine/filter/asserting_test'

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

@@ -18,6 +18,66 @@ module Wongi::Engine
         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

data/lib/wongi-engine/network.rb

@@ -169,6 +169,10 @@ module Wongi::Engine
 
     def retract wme, is_real = false
 
+      if wme.is_a? Array
+        return retract( WME.new(*wme), is_real )
+      end
+
       if ! is_real
         if @current_context
           @current_context.retracted_wmes << wme
@@ -386,7 +390,7 @@ module Wongi::Engine
       beta = root.network conditions, [], parameters, alpha_deaf
 
       production = ProductionNode.new( beta, actions )
-      production.update_above
+      production.refresh
       production
     end
 

data/lib/wongi-engine/token.rb

@@ -19,7 +19,6 @@ module Wongi::Engine
       @opt_join_results = []
       @ncc_results = []
       @generated_wmes = []
-      @deexecutors = []
       token.children << self if token
       wme.tokens << self if wme
     end
@@ -48,51 +47,21 @@ module Wongi::Engine
 
     def wmes
       if parent
-        parent.wmes + [wme]
+        parent.wmes + (wme ? [wme] : [])
       else
-        [wme]
+        wme ? [wme] : []
       end
     end
 
-    def delete preserve_self = false
+    def delete
       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 )
+      @node.tokens.delete self unless @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
 
+      @node.delete_token self
     end
 
     def delete_children
@@ -118,11 +87,6 @@ module Wongi::Engine
 
     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

data/lib/wongi-engine/version.rb

@@ -1,5 +1,5 @@
 module Wongi
   module Engine
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/wongi-engine/wme.rb

@@ -57,7 +57,7 @@ module Wongi::Engine
 
       alphas.each { |alpha| alpha.remove self }.clear
       while tokens.first
-        tokens.first.delete self    # => will remove itself from the array
+        tokens.first.delete    # => will remove itself from the array
       end
 
       destroy_neg_join_results
@@ -90,9 +90,9 @@ module Wongi::Engine
         results = token.neg_join_results
         results.delete njr
 
-        if results.empty? && !rete.in_snapshot?
+        if results.empty? #&& !rete.in_snapshot?
           token.node.children.each { |beta|
-            beta.left_activate token, nil, { }
+            beta.beta_activate token, nil, { }
           }
         end
 
@@ -109,7 +109,7 @@ module Wongi::Engine
         if results.empty?
           token.delete_children
           token.node.children.each { |beta|
-            beta.left_activate token
+            beta.beta_activate token
           }
         end
 

data/lib/wongi-engine.rb

@@ -14,6 +14,7 @@ require 'wongi-engine/template'
 require 'wongi-engine/wme'
 require 'wongi-engine/wme_match_data'
 require 'wongi-engine/token'
+require 'wongi-engine/filter'
 require 'wongi-engine/alpha_memory'
 require 'wongi-engine/beta'
 require 'wongi-engine/dsl'

data/spec/filter_specs/assert_test_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe "ASSERT test" do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  def production
+    @production
+  end
+
+  def test_rule &block
+    @production = ( engine << rule( 'test-rule', &block ) )
+  end
+
+  it "should pass with a constant 'true'" do
+
+    test_rule {
+      forall {
+        assert { |token|
+          true
+        }
+      }
+    }
+
+    production.should have(1).tokens
+    
+  end
+
+  it "should fail with a constant 'false'" do
+
+    test_rule {
+      forall {
+        assert { |token|
+          false
+        }
+      }
+    }
+
+    production.should have(0).tokens
+
+  end
+
+  it "should use the token with no arguments" do
+
+    test_rule {
+      forall {
+        has :X, "is", :Y
+        assert { |token|
+          token[:X] == "resistance"
+        }
+      }
+    }
+
+    engine << ["resistance", "is", "futile"]
+
+    production.should have(1).tokens
+    production.tokens.first[:X].should == "resistance"
+
+  end
+
+  it "should use individual variables with arguments" do
+
+    test_rule {
+      forall {
+        has :X, "is", :Y
+        assert :X, :Y do |x, y|
+          y == "futile"
+        end
+      }
+    }
+
+    engine << ["resistance", "is", "futile"]
+
+    production.should have(1).tokens
+    production.tokens.first[:X].should == "resistance"
+
+  end
+
+end

data/spec/high_level_spec.rb

@@ -178,63 +178,7 @@ describe 'the engine' do
     rete.results["test-query"].tokens.first[:Y].should == 42
 
   end
-
-  it 'should support negative subnets' do
-
-    production = (rete << rule('ncc') {
-      forall {
-        has "base", "is", :Base
-        none {
-          has :Base, 2, :X
-          has :X, 4, 5
-        }
-      }
-    })
-
-    rete << ["base", "is", 1]
-
-    production.should have(1).tokens
-
-    rete << [1, 2, 3]
-
-    production.should have(1).tokens
-
-    rete << [3, 4, 5]
-
-    production.should have(0).tokens
-
-    rete << ["base", "is", 2]
-
-    production.should have(1).tokens
-
-  end
-
-  it 'should support optional matches' do
-
-    production = (rete << rule('optional') {
-      forall {
-        has "answer", "is", :Answer
-        maybe :Answer, "is", :Kind
-      }
-    })
-
-    rete << ["answer", "is", 42]
-    rete << ["answer", "is", 43]
-    rete << [42, "is", "canonical"]
-
-    production.should have(2).tokens
-
-    canon = production.tokens.select { |token| not token[:Kind].nil? }
-    canon.should have(1).items
-    canon.first[:Answer].should == 42
-    canon.first[:Kind].should == "canonical"
-
-    non_canon = production.tokens.select { |token| token[:Kind].nil? }
-    non_canon.should have(1).items
-    non_canon.first[:Answer].should == 43
-
-  end
-
+  
   context 'with timelines' do
 
     it 'should not match with no past point' do
@@ -282,7 +226,7 @@ describe 'the engine' do
         rete.snapshot!
         rete << [1, 2, 3]
         production.should have(1).tokens
-        puts count
+        #puts count
       end
 
       it 'should not match kept items' do
@@ -297,7 +241,7 @@ describe 'the engine' do
         production.should have(1).tokens
         rete.snapshot!
         production.should have(0).tokens
-        puts count
+        #puts count
       end
 
     end
@@ -316,7 +260,7 @@ describe 'the engine' do
         production.should have(0).tokens
         rete.snapshot!
         production.should have(1).tokens
-        puts count
+        #puts count
       end
 
       it 'should not match asserted wmes' do
@@ -331,7 +275,7 @@ describe 'the engine' do
         rete.snapshot!
         rete << [1, 2, 3]
         production.should have(0).tokens
-        puts count
+        #puts count
       end
 
     end

data/spec/rule_specs/any_rule_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe "ANY rule" do
+
+    before :each do
+      @engine = Wongi::Engine.create
+    end
+
+    def engine
+      @engine
+    end
+  
+    context "with just one option" do
+
+      it "should act like a positive matcher" do
+
+        engine << rule('one-option') {
+          forall {
+            any {
+              option {
+                has 1, 2, :X
+                has :X, 4, 5
+              }
+            }
+          }
+        }
+
+        production = engine.productions['one-option']
+
+        engine << [1, 2, 3]
+        engine << [3, 4, 5]
+
+        production.should have(1).tokens
+
+      end
+
+    end
+
+    context "with several options" do
+
+      specify "all matching branches must pass" do
+
+        engine << rule('two-options') {
+          forall {
+            has 1, 2, :X
+            any {
+              option {
+                has :X, 4, 5
+              }
+              option {
+                has :X, "four", "five"
+              }
+            }
+          }
+          make {
+            collect :X, :threes
+          }
+        }
+
+        production = engine.productions['two-options']
+
+        engine << [1, 2, 3]
+        engine << [3, 4, 5]
+        engine << [1, 2, "three"]
+        engine << ["three", "four", "five"]
+
+        production.should have(2).tokens
+        engine.collection(:threes).should include(3)
+        engine.collection(:threes).should include("three")
+
+      end
+
+    end
+
+end

data/spec/rule_specs/assign_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe "ASSIGN rule" do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  def production
+    @production
+  end
+
+  def test_rule &block
+    @production = ( engine << rule( 'test-rule', &block ) )
+  end
+
+  it "should assign simple expressions" do
+
+    test_rule {
+      forall {
+        assign :X do
+          42
+        end
+      }
+    }
+
+    production.should have(1).tokens
+    production.tokens.first[:X].should == 42
+
+  end
+
+  it "should be able to access previous assignments" do
+
+    test_rule {
+      forall {
+        has 1, 2, :X
+        assign :Y do |token|
+          token[:X] * 2
+        end
+      }
+    }
+
+    engine << [1, 2, 5]
+    production.tokens.first[:Y].should == 10
+
+  end
+
+end