mort666-wongi-engine 0.2.9

data/spec/overlay_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Wongi::Engine::DataOverlay do
+  include Wongi::Engine::DSL
+
+  let(:engine) { Wongi::Engine.create }
+
+  it 'should be disposable' do
+    production = engine << rule {
+      forall {
+        has 1, 2, :X
+      }
+    }
+    engine.with_overlay { |overlay|
+      overlay << [1,2,3]
+      expect(production).to have(1).token
+    }
+    expect(production).to have(0).tokens
+  end
+
+  it 'should generate into correct overlays' do
+    production = engine << rule {
+      forall {
+        has 1, 2, :X
+      }
+      make {
+        gen :X, 4, 5
+      }
+    }
+    engine.with_overlay { |overlay|
+      overlay << [1,2,3]
+      expect(production).to have(1).token
+      expect(engine.find(3, 4, 5)).not_to be_nil
+    }
+    expect(production).to have(0).tokens
+    expect(engine.find(3, 4, 5)).to be_nil
+  end
+
+  it 'works with assignments' do
+    production = engine << rule {
+      forall {
+        has 1, 2, :X
+        assign(:Something) { 6 }
+      }
+      make {
+        collect :Something, :stuff
+        gen :person, 'stuff', :Something
+      }
+    }
+
+    engine.with_overlay { |overlay|
+      overlay << [1,2,3]
+      expect(production).to have(1).token
+      expect(engine.find(:_, :_, :_)).not_to be_nil
+    }
+
+    expect(production).to have(0).tokens
+    expect(engine.find(:_, :_, :_)).to be_nil
+  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]
+
+        expect(production.size).to eq(1)
+
+      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"]
+
+        expect(production.size).to eq(2)
+        expect( engine.collection(:threes) ).to include(3)
+        expect( engine.collection(:threes) ).to include("three")
+
+      end
+
+    end
+
+end

data/spec/rule_specs/assign_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe "ASSIGN rule" do
+
+  let( :engine ) { Wongi::Engine.create }
+
+  it "should assign simple expressions" do
+
+    production = engine << rule {
+      forall {
+        assign :X do
+          42
+        end
+      }
+    }
+    expect(production.size).to eq(1)
+    expect(production.tokens.first[:X]).to eq(42)
+
+  end
+
+  it "should be able to access previous assignments" do
+
+    production = engine << rule {
+      forall {
+        has 1, 2, :X
+        assign :Y do |token|
+          token[:X] * 2
+        end
+      }
+    }
+
+    engine << [1, 2, 5]
+    expect(production.tokens.first[:Y]).to eq(10)
+
+  end
+
+  it 'should be deactivatable' do
+
+    prod = engine << rule {
+      forall {
+        has 1, 2, :X
+        assign :Y do |token|
+          token[:X] * 2
+        end
+      }
+    }
+
+    engine << [1, 2, 5]
+    engine.retract [1, 2, 5]
+
+    expect( prod ).to have(0).tokens
+
+  end
+
+  it 'should be evaluated once' do
+    x = 0
+    prod = engine << rule {
+      forall {
+        has :a, :b, :c
+        assign :T do
+          x += 1
+        end
+      }
+      make {
+        gen :d, :e, :T
+        gen :f, :g, :T
+      }
+    }
+    engine << [:a, :b, :c]
+    expect(x).to be == 1
+  end
+
+  it 'should handle booleans' do
+    engine << rule do
+      for_all {
+        has :a, :b, :c
+        assign :X do |token|
+          false
+        end
+      }
+      make {
+        gen :d, :e, :X
+      }
+    end
+    engine << [:a, :b, :c]
+  end
+
+end

data/spec/rule_specs/assuming_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Wongi::Engine::AssumingClause do
+
+  let( :engine ) { Wongi::Engine.create }
+
+  it 'should include base rules' do
+
+    engine << rule( :base ) {
+      forall {
+        has :x, :y, :Z
+      }
+    }
+
+    extended = engine << rule {
+      forall {
+        assuming :base
+        has :Z, :u, :W
+      }
+    }
+
+    engine << [:x, :y, 1]
+    engine << [:x, :y, 2]
+    engine << [1, :u, :a]
+    engine << [2, :u, :b]
+    result = Hash[ extended.tokens.map { |token| [ token[:Z], token[:W] ] } ]
+    expect( result ).to eq(1 => :a, 2 => :b)
+
+  end
+
+  it 'should check for base rule\'s existence' do
+
+    f = -> {
+      engine << rule {
+        forall {
+          assuming :base
+        }
+      }
+    }
+
+    expect( &f ).to raise_error Wongi::Engine::UndefinedBaseRule
+
+  end
+
+  it 'should come first in a rule' do
+
+    f = -> {
+      engine << rule( :base ) {
+        forall {
+          has :x, :y, :Z
+        }
+      }
+
+      engine << rule {
+        forall {
+          has :Z, :u, :W
+          assuming :base
+        }
+      }
+    }
+
+    expect( &f ).to raise_error Wongi::Engine::DefinitionError
+    
+  end
+
+end

data/spec/rule_specs/maybe_rule_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe "MAYBE rule" do
+
+  let( :engine ) { Wongi::Engine.create }
+  let( :maybe_rule ) {
+    rule {
+      forall {
+        has 1, 2, :X
+        maybe :X, 4, :Y
+      }
+    }
+  }
+
+  it "should pass with existing facts" do
+
+    production = engine << maybe_rule
+
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+
+    expect(production.size).to eq(1)
+
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to eq(5)
+
+  end
+
+  it "should pass with missing facts" do
+
+    production = engine << maybe_rule
+
+    engine << [1, 2, 3]
+
+    expect(production.size).to eq(1)
+
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to be_nil
+
+  end
+
+  it "should pass with pre-added missing facts" do
+
+    engine << [1, 2, 3]
+
+    production = engine << maybe_rule
+
+    expect(production.size).to eq(1)
+
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to be_nil
+
+  end
+
+  it 'should pass with retracted facts' do
+
+    prod = engine << maybe_rule
+
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+    engine.retract [3, 4, 5]
+
+    expect(prod.size).to eq(1)
+
+    expect(prod.tokens.first[:X]).to eq(3)
+    expect(prod.tokens.first[:Y]).to be_nil
+
+  end
+
+  it 'should work with repeated activations' do
+
+    prod = engine << maybe_rule
+
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+    engine.retract [3, 4, 5]
+
+    10.times {
+      engine << [3, 4, 5]
+      expect(prod.size).to eq(1)
+      expect(prod.tokens.first[:Y]).to be == 5
+
+      engine.retract [3, 4, 5]
+      expect(prod.size).to eq(1)
+      expect(prod.tokens.first[:Y]).to be_nil
+    }
+
+  end
+
+  it 'should handle retracted parent tokens' do
+    prod = engine << maybe_rule
+
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+    engine.retract [1, 2, 3]
+
+    expect(prod).to have(0).tokens
+    expect(engine.find(3,4,5).opt_join_results).to be_empty
+  end
+
+end

data/spec/rule_specs/ncc_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+describe Wongi::Engine::NccNode do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  def ncc_rule
+    rule('ncc') {
+      forall {
+        has "base", "is", :Base
+        none {
+          has :Base, 2, :X
+          has :X, 4, 5
+        }
+      }
+    }
+  end
+
+  def ncc_rule_post_has
+    rule('ncc post has') {
+      forall {
+        has "base", "is", :Base
+        none {
+          has :Base, 2, :X
+          has :X, 4, 5
+        }
+        has "base", "is", :Base2
+      }
+    }
+  end
+
+  it 'should pass with a mismatching subchain' do
+
+    engine << ncc_rule
+    production = engine.productions['ncc']
+
+    engine << ["base", "is", 1]
+
+    expect(production).to have(1).token
+
+    engine << [1, 2, 3]
+
+    expect(production).to have(1).token
+
+    engine << [3, 4, 5]
+
+    expect(production).to have(0).token
+
+  end
+
+  it 'should remain consistent after retraction' do
+
+    engine << ncc_rule
+    production = engine.productions['ncc']
+
+    engine << ["base", "is", 1]
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+
+    expect(production).to have(0).tokens
+
+    engine.retract [3, 4, 5]
+    expect( production ).to have(1).token
+
+    engine.retract ["base", "is", 1]
+    expect(production).to have(0).tokens
+
+  end
+
+  it 'can handle an alpha node template introduced after the negative-conjunctive-condition' do
+
+    engine << ncc_rule_post_has
+
+    production = engine.productions['ncc post has']
+
+    engine << ["base", "is", 1]
+    engine << [1, 2, 3]
+    engine << [3, 4, 5]
+
+    expect( production ).to have(0).tokens
+
+    engine.retract [3, 4, 5]
+    expect( production ).to have(1).tokens
+
+    engine.retract ["base", "is", 1]
+    expect( production ).to have(0).tokens
+
+  end
+
+  it 'should clean up correctly' do
+
+    engine.rule :rule1 do
+      forall {
+        has :light_kitchen, :value, :on
+      }
+      make {
+        #trace values: true, generation: true
+        gen self.name, :light_bathroom, :on
+        gen self.name, :want_action_for, :light_bathroom
+      }
+    end
+
+    prod = engine.rule "action" do
+      forall {
+        has :Requestor, :want_action_for, :Actor
+        has :Requestor, :Actor, :Value
+        has :Requestor, :priority, :Priority
+        ncc {
+          has :OtherRequestor, :want_action_for, :Actor
+          diff :OtherRequestor, :Requestor
+          has :OtherRequestor, :priority, :OtherPriority
+          greater :OtherPriority, :Priority
+        }
+      }
+      make {
+        #trace values: true, generation: true
+        gen :Actor, :value, :Value
+        gen :Actor, :last_user, :Requestor
+      }
+    end
+
+    engine << [:user, :priority, 1]
+    engine << [:rule1, :priority, 2]
+    engine << [:poweruser, :priority, 3]
+    engine << [:god, :priority, 4]
+
+    engine << [:user, :want_action_for, :light_bathroom]
+    engine << [:user, :light_bathroom, :off]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :off) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :user) ]
+
+    engine << [:light_kitchen, :value, :on]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :on) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :rule1) ]
+
+    engine << [:poweruser, :want_action_for, :light_bathroom]
+    engine << [:poweruser, :light_bathroom, :super_on]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :super_on) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :poweruser) ]
+
+    engine << [:god, :want_action_for, :light_bathroom]
+    engine << [:god, :light_bathroom, :let_there_be_light]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :let_there_be_light) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :god) ]
+
+  end
+
+  it 'should clean up correctly with a different activation order' do
+
+    engine.rule :rule1 do
+      forall {
+        has :light_kitchen, :value, :on
+      }
+      make {
+        #trace values: true, generation: true
+        gen self.name, :light_bathroom, :on
+        gen self.name, :want_action_for, :light_bathroom
+      }
+    end
+
+    prod = engine.rule "action" do
+      forall {
+        has :Requestor, :want_action_for, :Actor
+        has :Requestor, :Actor, :Value
+        has :Requestor, :priority, :Priority
+        ncc {
+          has :OtherRequestor, :want_action_for, :Actor
+          diff :OtherRequestor, :Requestor
+          has :OtherRequestor, :priority, :OtherPriority
+          greater :OtherPriority, :Priority
+        }
+      }
+      make {
+        #trace values: true, generation: true
+        gen :Actor, :value, :Value
+        gen :Actor, :last_user, :Requestor
+      }
+    end
+
+    engine << [:user, :priority, 2]
+    engine << [:rule1, :priority, 1]
+    engine << [:poweruser, :priority, 3]
+    engine << [:god, :priority, 4]
+
+    engine << [:user, :want_action_for, :light_bathroom]
+    engine << [:user, :light_bathroom, :off]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :off) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :user) ]
+
+    engine << [:light_kitchen, :value, :on]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :off) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :user) ]
+
+    engine << [:poweruser, :want_action_for, :light_bathroom]
+    engine << [:poweruser, :light_bathroom, :super_on]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :super_on) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :poweruser) ]
+
+    engine << [:god, :want_action_for, :light_bathroom]
+    engine << [:god, :light_bathroom, :let_there_be_light]
+    expect( engine.select(:light_bathroom, :value, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :value, :let_there_be_light) ]
+    expect( engine.select(:light_bathroom, :last_user, :_) ).to be == [ Wongi::Engine::WME.new(:light_bathroom, :last_user, :god) ]
+
+  end
+
+  it 'should ncc-deactivate without destroying tokens' do
+    engine << rule {
+      forall {
+        has :Student, :is_a, :student
+        has :Course, :is_a, :course
+        none {
+          has :Requirement, :is_a, :requirement
+          has :Course, :Requirement, :RequiredGrade
+          any {
+            option {
+              neg :Student, :Requirement, :_
+            }
+            option {
+              has :Student, :Requirement, :ReceivedGrade
+              less :ReceivedGrade, :RequiredGrade
+            }
+          }
+        }
+      }
+      make {
+        gen :Student, :passes_for, :Course
+      }
+    }
+
+    %w( math science english bio ).each { |req| engine << [ req, :is_a, :requirement ] }
+    %w( CourseA CourseB CourseC ).each  { |course| engine << [ course, :is_a, :course ] }
+    engine << [ "StudentA", :is_a, :student ]
+
+    engine << ["CourseA", "math", 50]
+    engine << ["CourseA", "science", 50]
+
+    engine << ["CourseB", "math", 50]
+    engine << ["CourseB", "english", 50]
+
+    engine << ["CourseC", "math", 50]
+    engine << ["CourseC", "bio", 50]
+
+    engine << ["StudentA", "math", 60]
+    engine << ["StudentA", "science", 60]
+    engine << ["StudentA", "bio", 40]
+
+    expect(engine.find "StudentA", :passes_for, "CourseA").not_to be_nil
+    expect(engine.find "StudentA", :passes_for, "CourseB").to be_nil
+    expect(engine.find "StudentA", :passes_for, "CourseC").to be_nil
+  end
+
+end