wongi-engine 0.0.1

data/lib/wongi-engine/wme_match_data.rb

@@ -0,0 +1,34 @@
+module Wongi::Engine
+
+  class WMEMatchData
+
+    attr_reader :assignments
+
+    def initialize assignments = { }, match = false
+      @assignments = assignments
+      @match = match
+    end
+
+    def [] key
+      assignments[key]
+    end
+
+    def []= key, value
+      assignments[key] = value
+    end
+
+    def match?
+      @match
+    end
+
+    def match!
+      @match = true
+    end
+
+    def & other
+      WMEMatchData.new( assignments.merge( other.assignments ), match? && other.match? )
+    end
+
+  end
+
+end

data/spec/dataset_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Wongi::Engine::Network do  
+
+  it 'should expose compiled productions' do
+
+    ds = Wongi::Engine::Network.new
+
+    ds << rule('test-rule') {
+      forall {
+        has 1, 2, 3
+      }
+    }
+
+    production = ds.productions['test-rule']
+    production.should_not be_nil
+
+    production.tokens.should be_empty
+
+    ds << [1, 2, 3]
+
+    production.should have(1).tokens
+
+  end
+
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'DSL' do
+
+  it 'should register rulesets globally' do
+
+  end
+
+end

data/spec/high_level_spec.rb

@@ -0,0 +1,341 @@
+require 'spec_helper'
+
+dsl {
+
+  section :make
+  clause :test_collector
+  action Wongi::Engine::SimpleCollector.collector
+
+}
+
+describe 'the engine' do
+
+  before :each do
+    @rete = Wongi::Engine::Network.new
+  end
+
+  def rete
+    @rete
+  end
+
+  context 'with a simple generative positive rule' do
+
+    it 'should generate wmes with an existing rule' do
+
+      rete << rule('symmetric') {
+        forall {
+          has :P, "symmetric", true
+          has :A, :P, :B
+        }
+        make {
+          gen :B, :P, :A
+        }
+      }
+
+      rete << Wongi::Engine::WME.new( "friend", "symmetric", true )
+      rete << Wongi::Engine::WME.new( "Alice", "friend", "Bob" )
+
+      rete.should have(3).facts
+      rete.facts.select( &:manual? ).should have(2).items
+      generated = rete.facts.find( &:generated? )
+      generated.should == Wongi::Engine::WME.new( "Bob", "friend", "Alice" )
+    end
+
+    it 'should generate wmes with an added rule' do
+
+      rete << Wongi::Engine::WME.new( "friend", "symmetric", true )
+      rete << Wongi::Engine::WME.new( "Alice", "friend", "Bob" )
+
+      rete.should have(2).facts
+
+      rete << rule('symmetric') {
+        forall {
+          has :P, "symmetric", true
+          has :A, :P, :B
+        }
+        make {
+          gen :B, :P, :A
+        }
+      }
+
+      rete.should have(3).facts
+      rete.facts.select( &:manual? ).should have(2).items
+    end
+
+  end
+
+  it 'should check equality' do
+
+    rete << rule('equality') {
+      forall {
+        fact :A, "same", :B
+        same :A, :B
+      }
+      make {
+
+      }
+    }
+
+    rete << [ 42, "same", 42 ]
+
+  end
+
+  it 'should use collectors' do
+
+    rete << rule('collector') {
+      forall {
+        has :X, :_, 42
+      }
+      make {
+        test_collector :X
+      }
+    }
+
+    rete << [ "answer", "is", 42 ]
+    rete << [ "question", "is", -1 ]
+
+    collection = rete.collection(:test_collector)
+    collection.should have(1).item
+    collection.first.should == "answer"
+
+  end
+
+  it 'should use generic collectors' do
+
+    rete << rule('generic-collector') {
+      forall {
+        has :X, :_, 42
+      }
+      make {
+        collect :X, :things_that_are_42
+      }
+    }
+
+    rete << [ "answer", "is", 42 ]
+    rete << [ "question", "is", -1 ]
+
+    collection = rete.collection(:things_that_are_42)
+    collection.should have(1).item
+    collection.first.should == "answer"
+
+  end
+
+  it 'should accept several rules' do
+
+    lambda do
+
+      rete << rule('generic-collector') {
+        forall {
+          has :X, :_, 42
+        }
+        make {
+          collect :X, :things_that_are_42
+        }
+      }
+
+      rete << rule('collector') {
+        forall {
+          has :X, :_, 42
+        }
+        make {
+          test_collector :X
+        }
+      }
+
+    end.should_not raise_error
+
+  end
+
+  it 'should process negative nodes' do
+
+    production = (rete << rule('negative') {
+      forall {
+        neg :_, :_, 42
+      }
+      })
+
+    production.should have(1).tokens
+
+    rete << [ "answer", "is", 42 ]
+
+    production.should have(0).tokens
+
+  end
+
+  it 'should support prepared queries' do
+
+    rete << query("test-query") {
+      search_on :X
+      forall {
+        has :X, "is", :Y
+      }
+    }
+
+    rete << ["answer", "is", 42]
+
+    rete.execute "test-query", {X: "answer"}
+    rete.results["test-query"].should have(1).tokens
+    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
+
+      production = rete.rule {
+        forall {
+          has 1, 2, 3, -1
+        }
+      }
+
+      production.should have(0).tokens
+
+      rete << [1, 2, 3]
+
+      production.should have(0).tokens
+
+    end
+
+    it 'should match a simple past point' do
+
+      production = rete.rule {
+        forall {
+          has 1, 2, 3, -1
+        }
+      }
+
+      rete << [1, 2, 3]
+      rete.snapshot!
+
+      production.should have(1).tokens
+
+    end
+
+    context 'using the :asserted clause' do
+
+      it 'should match asserted items' do
+        count = 0
+        production = rete.rule do
+          forall {
+            asserted 1, 2, 3
+          }
+          make { action { count += 1} }
+        end
+        production.should have(0).tokens
+        rete.snapshot!
+        rete << [1, 2, 3]
+        production.should have(1).tokens
+        puts count
+      end
+
+      it 'should not match kept items' do
+        count = 0
+        production = rete.rule do
+          forall {
+            asserted 1, 2, 3
+          }
+          make { action { count += 1} }
+        end
+        rete << [1, 2, 3]
+        production.should have(1).tokens
+        rete.snapshot!
+        production.should have(0).tokens
+        puts count
+      end
+
+    end
+
+    context 'using the :kept clause' do
+
+      it 'should match kept items' do
+        count = 0
+        production = rete.rule do
+          forall {
+            kept 1, 2, 3
+          }
+          make { action { count += 1} }
+        end
+        rete << [1, 2, 3]
+        production.should have(0).tokens
+        rete.snapshot!
+        production.should have(1).tokens
+        puts count
+      end
+
+      it 'should not match asserted wmes' do
+        count = 0
+        production = rete.rule do
+          forall {
+            kept 1, 2, 3
+          }
+          make { action { count += 1} }
+        end
+        production.should have(0).tokens
+        rete.snapshot!
+        rete << [1, 2, 3]
+        production.should have(0).tokens
+        puts count
+      end
+
+    end
+
+  end
+
+end

data/spec/ruleset_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Wongi::Engine::Ruleset do
+
+  before :each do
+    Wongi::Engine::Ruleset.reset
+  end
+
+  context 'initially' do
+
+    it 'should have no rules' do
+      Wongi::Engine::Ruleset.rulesets.should be_empty
+    end
+
+  end
+
+  context 'when creating' do
+
+    it 'should not register itself when not given a name' do
+      ruleset = Wongi::Engine::Ruleset.new
+      ruleset.name.should be_nil
+      Wongi::Engine::Ruleset.rulesets.should be_empty
+    end
+
+    it 'should have a name' do
+      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
+      ruleset.name.should == 'testing-ruleset'
+    end
+
+    it 'should register itself when given a name' do
+      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
+      Wongi::Engine::Ruleset.rulesets.should_not be_empty
+      Wongi::Engine::Ruleset[ruleset.name].should == ruleset
+    end
+
+  end
+
+  it 'should be able to clear registered rulesets' do
+    ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
+    Wongi::Engine::Ruleset.reset
+    Wongi::Engine::Ruleset.rulesets.should be_empty
+  end
+
+  it 'should install creating rules into a rete' do
+    rete = mock 'rete'
+    
+    ruleset = Wongi::Engine::Ruleset.new
+    rule = ruleset.rule( 'test-rule' ) { }
+
+    rete.should_receive(:<<).with(rule).once
+    ruleset.install rete
+  end
+
+end