wongi-engine 0.3.6 → 0.3.7

data/spec/network_spec.rb

@@ -1,60 +1,85 @@
 require 'spec_helper'
 
 describe Wongi::Engine::Network do
+  include Wongi::Engine::DSL
 
-  let( :engine ) { Wongi::Engine.create }
+  let(:engine) { Wongi::Engine.create }
   subject { engine }
 
   it 'should assert facts' do
-    subject << [1,2,3]
-    expect( subject.select( :_, 2, :_) ).to have(1).item
+    subject << [1, 2, 3]
+    expect(subject.select(:_, 2, :_)).to have(1).item
   end
 
   it 'should retract facts' do
-    subject << [1,2,3]
-    subject.retract [1,2,3]
-    expect( subject.select( :_, 2, :_) ).to be_empty
+    subject << [1, 2, 3]
+    subject.retract [1, 2, 3]
+    expect(subject.select(:_, 2, :_)).to be_empty
   end
 
   it 'asserted facts end up in productions' do
-
     prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1,2,3]
-    expect( prod ).to have(1).tokens
+    subject << [1, 2, 3]
+    expect(prod).to have(1).tokens
+  end
+
+  it 'rules can be removed from engine' do
+    subject << [1, 2, 3]
+    subject << [4, 5, 6]
+
+    prod1 = subject << rule { forall { has :X, 2, :Z } }
+    prod2 = subject << rule { forall { has :X, 5, :Z } }
+
+    expect(prod1).to have(1).tokens
+    expect(prod2).to have(1).tokens
 
+    subject.remove_production(prod1)
+
+    expect(prod1).to have(0).tokens
+    expect(prod2).to have(1).tokens
   end
 
-  it 'retracted facts are removed from productions' do
+  it 'new rules can be added to engine after a rule has been been removed' do
+    subject << [1, 2, 3]
+    subject << [4, 5, 6]
 
-    prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1,2,3]
-    subject.retract [1,2,3]
-    expect( prod ).to have(0).tokens
+    prod1 = subject << rule { forall { has :X, 2, :Z } }
+
+    expect(prod1).to have(1).tokens
 
+    subject.remove_production(prod1)
+    expect(prod1).to have(0).tokens
+
+    prod2 = subject << rule { forall { has :X, 5, :Z } }
+    expect(prod2).to have(1).tokens
   end
 
-  it 'retracted facts should trigger deactivation' do
+  it 'retracted facts are removed from productions' do
+    prod = subject << rule { forall { has :X, 2, :Z } }
+    subject << [1, 2, 3]
+    subject.retract [1, 2, 3]
+    expect(prod).to have(0).tokens
+  end
 
+  it 'retracted facts should trigger deactivation' do
     activated_z = nil
     deactivated_z = nil
 
-    prod = subject << rule {
+    subject << rule {
       forall { has :X, 2, :Z }
       make {
         action activate: ->(token) { activated_z = token[:Z] },
                deactivate: ->(token) { deactivated_z = token[:Z] }
       }
     }
-    subject << [1,2,3]
-    expect( activated_z ).to be == 3
-
-    subject.retract [1,2,3]
-    expect( deactivated_z ).to be == 3
+    subject << [1, 2, 3]
+    expect(activated_z).to be == 3
 
+    subject.retract [1, 2, 3]
+    expect(deactivated_z).to be == 3
   end
 
   it 'retracted facts should propagate through join chains' do
-
     deactivated = nil
 
     prod = engine << rule {
@@ -70,113 +95,97 @@ describe Wongi::Engine::Network do
     engine << [1, :is, 2]
     engine << [2, :is, 3]
 
-    expect( prod ).to have(1).tokens
+    expect(prod).to have(1).tokens
 
     engine.retract [1, :is, 2]
-    expect( prod ).to have(0).tokens
-    expect( deactivated[:X] ).to be == 1
-    expect( deactivated[:Y] ).to be == 2
-    expect( deactivated[:Z] ).to be == 3
-
+    expect(prod).to have(0).tokens
+    expect(deactivated[:X]).to be == 1
+    expect(deactivated[:Y]).to be == 2
+    expect(deactivated[:Z]).to be == 3
   end
 
   it 'retraction should reactivate neg nodes' do
+    prod = engine << rule { forall { neg 1, 2, 3 } }
 
-    prod = engine << rule { forall { neg 1, 2, 3} }
-
-    expect( prod ).to have(1).tokens
+    expect(prod).to have(1).tokens
 
-    engine << [1, 2 ,3]
-    expect( prod ).to have(0).tokens
+    engine << [1, 2, 3]
+    expect(prod).to have(0).tokens
 
     engine.retract [1, 2, 3]
-    expect( prod ).to have(1).tokens
-
+    expect(prod).to have(1).tokens
   end
 
   describe 'retraction with neg nodes lower in the chain' do
-
-    def expect_tokens n
-      expect( prod ).to have(n).tokens
+    def expect_tokens(n)
+      expect(prod).to have(n).tokens
     end
 
-    before :each do
-
+    before do
       engine << rule('retract') {
         forall {
           has :x, :u, :Y
           neg :Y, :w, :_
         }
       }
-
     end
 
-    let( :prod ) { engine.productions['retract'] }
+    let(:prod) { engine.productions['retract'] }
 
     specify 'case 1' do
-
-      engine << [:x, :u, :y]
+      engine << %i[x u y]
       expect_tokens 1
 
-      engine << [:y, :w, :z]
+      engine << %i[y w z]
       expect_tokens 0
 
-      engine.retract [:y, :w, :z]
+      engine.retract %i[y w z]
       expect_tokens 1
 
-      engine.retract [:x, :u, :y]
+      engine.retract %i[x u y]
       expect_tokens 0
-
     end
 
     specify 'case 2' do
-
-      engine << [:x, :u, :y]
+      engine << %i[x u y]
       expect_tokens 1
 
-      engine << [:y, :w, :z]
+      engine << %i[y w z]
       expect_tokens 0
 
-      engine.retract [:x, :u, :y]
+      engine.retract %i[x u y]
       expect_tokens 0
 
-      engine.retract [:y, :w, :z]
+      engine.retract %i[y w z]
       expect_tokens 0
-
     end
 
     specify 'case 3' do
-
-      engine << [:y, :w, :z]
+      engine << %i[y w z]
       expect_tokens 0
 
-      engine << [:x, :u, :y]
+      engine << %i[x u y]
       expect_tokens 0
 
-      engine.retract [:x, :u, :y]
+      engine.retract %i[x u y]
       expect_tokens 0
 
-      engine.retract [:y, :w, :z]
+      engine.retract %i[y w z]
       expect_tokens 0
-
     end
 
     specify 'case 4' do
-
-      engine << [:y, :w, :z]
+      engine << %i[y w z]
       expect_tokens 0
 
-      engine << [:x, :u, :y]
+      engine << %i[x u y]
       expect_tokens 0
 
-      engine.retract [:y, :w, :z]
+      engine.retract %i[y w z]
       expect_tokens 1
 
-      engine.retract [:x, :u, :y]
+      engine.retract %i[x u y]
       expect_tokens 0
-
     end
-
   end
-
 end

data/spec/overlay_spec.rb

@@ -12,7 +12,7 @@ describe Wongi::Engine::DataOverlay do
       }
     }
     engine.with_overlay { |overlay|
-      overlay << [1,2,3]
+      overlay << [1, 2, 3]
       expect(production).to have(1).token
     }
     expect(production).to have(0).tokens
@@ -28,7 +28,7 @@ describe Wongi::Engine::DataOverlay do
       }
     }
     engine.with_overlay { |overlay|
-      overlay << [1,2,3]
+      overlay << [1, 2, 3]
       expect(production).to have(1).token
       expect(engine.find(3, 4, 5)).not_to be_nil
     }
@@ -49,13 +49,12 @@ describe Wongi::Engine::DataOverlay do
     }
 
     engine.with_overlay { |overlay|
-      overlay << [1,2,3]
+      overlay << [1, 2, 3]
       expect(production).to have(1).token
-      expect(engine.find(:_, :_, :_)).not_to be_nil
+      expect(engine.find(:person, 'stuff', 6)).not_to be_nil
     }
 
     expect(production).to have(0).tokens
     expect(engine.find(:_, :_, :_)).to be_nil
   end
-
 end

data/spec/rule_specs/aggregate_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'aggregate' do
+  include Wongi::Engine::DSL
+
+  let(:engine) { Wongi::Engine.create }
+  let(:rule_name) { SecureRandom.alphanumeric(16) }
+  let(:production) { engine.productions[rule_name] }
+
+  context 'generic clause' do
+    it 'should return a single token' do
+      engine << rule(rule_name) do
+        forall {
+          aggregate :_, :weight, :_, on: :object, function: :min, assign: :X
+        }
+      end
+
+      expect(production.size).to be == 0
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+
+      engine << [:melon, :weight, 15]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+
+      engine.retract [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 15
+
+      engine.retract [:melon, :weight, 15]
+      expect(production.size).to be == 0
+    end
+  end
+
+  context 'least' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          least :_, :weight, :_, on: :object, assign: :X
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+
+      engine.retract [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+    end
+  end
+
+  context 'min' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          min :_, :weight, :_, on: :object, assign: :X
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+
+      engine.retract [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+    end
+  end
+
+  context 'greatest' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          greatest :_, :weight, :_, on: :object, assign: :X
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+    end
+  end
+
+  context 'max' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          max :_, :weight, :_, on: :object, assign: :X
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 5
+      expect(production.tokens.first[:Fruit]).to be == :apple
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:X]).to be == 2
+      expect(production.tokens.first[:Fruit]).to be == :pea
+    end
+  end
+
+  context 'count' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          count :_, :weight, :_, assign: :Count
+        }
+      end
+
+      engine << [:pea, :weight, 1]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:Count]).to be == 1
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:Count]).to be == 2
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:Count]).to be == 3
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:Count]).to be == 2
+    end
+
+    it 'works with a post-filter' do
+      engine << rule(rule_name) do
+        forall {
+          count :_, :weight, :_, assign: :Count
+          gte :Count, 3 # pass if at least 3 matching facts exist
+        }
+      end
+
+      engine << [:pea, :weight, 1]
+      expect(production.size).to be == 0
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 0
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 1
+      expect(production.tokens.first[:Count]).to be == 3
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 0
+    end
+  end
+end

data/spec/rule_specs/any_rule_spec.rb

@@ -1,21 +1,12 @@
 require 'spec_helper'
 
 describe "ANY rule" do
-
   include Wongi::Engine::DSL
 
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
+  let(:engine) { Wongi::Engine.create }
 
   context "with just one option" do
-
     it "should act like a positive matcher" do
-
       engine << rule('one-option') {
         forall {
           any {
@@ -33,15 +24,11 @@ describe "ANY rule" do
       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
@@ -64,14 +51,12 @@ describe "ANY rule" do
       engine << [1, 2, 3]
       engine << [3, 4, 5]
       engine << [1, 2, "three"]
-      engine << ["three", "four", "five"]
+      engine << %w[three four five]
 
       expect(production.size).to eq(2)
-      expect( engine.collection(:threes) ).to include(3)
-      expect( engine.collection(:threes) ).to include("three")
-
+      expect(engine.collection(:threes)).to include(3)
+      expect(engine.collection(:threes)).to include("three")
     end
-
   end
 
   context "with two options and same assignments" do

data/spec/rule_specs/assign_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
 describe "ASSIGN rule" do
-
-  let( :engine ) { Wongi::Engine.create }
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   it "should assign simple expressions" do
-
     production = engine << rule {
       forall {
         assign :X do
@@ -15,7 +14,6 @@ describe "ASSIGN rule" do
     }
     expect(production.size).to eq(1)
     expect(production.tokens.first[:X]).to eq(42)
-
   end
 
   it 'should be available in the make section' do
@@ -35,7 +33,6 @@ describe "ASSIGN rule" do
   end
 
   it "should be able to access previous assignments" do
-
     production = engine << rule {
       forall {
         has 1, 2, :X
@@ -47,11 +44,9 @@ describe "ASSIGN rule" do
 
     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
@@ -64,13 +59,12 @@ describe "ASSIGN rule" do
     engine << [1, 2, 5]
     engine.retract [1, 2, 5]
 
-    expect( prod ).to have(0).tokens
-
+    expect(prod).to have(0).tokens
   end
 
   it 'should be evaluated once' do
     x = 0
-    prod = engine << rule {
+    engine << rule {
       forall {
         has :a, :b, :c
         assign :T do
@@ -82,15 +76,15 @@ describe "ASSIGN rule" do
         gen :f, :g, :T
       }
     }
-    engine << [:a, :b, :c]
+    engine << %i[a b c]
     expect(x).to be == 1
   end
 
-  it 'should handle booleans' do
+  xit 'should handle booleans' do
     engine << rule do
-      for_all {
+      forall {
         has :a, :b, :c
-        assign :X do |token|
+        assign :X do |_token|
           false
         end
       }
@@ -98,7 +92,7 @@ describe "ASSIGN rule" do
         gen :d, :e, :X
       }
     end
-    engine << [:a, :b, :c]
+    engine << %i[a b c]
+    expect(engine.find(:d, :e, false)).not_to be_nil
   end
-
 end

data/spec/rule_specs/assuming_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe Wongi::Engine::AssumingClause do
-
-  let( :engine ) { Wongi::Engine.create }
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   it 'should include base rules' do
-
-    engine << rule( :base ) {
+    engine << rule(:base) {
       forall {
         has :x, :y, :Z
       }
@@ -23,14 +22,12 @@ describe Wongi::Engine::AssumingClause do
     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)
-
+    result = extended.tokens.to_h { |token| [token[:Z], token[:W]] }
+    expect(result).to eq(1 => :a, 2 => :b)
   end
 
   it 'should check for base rule\'s existence' do
-
-    f = -> {
+    f = lambda {
       engine << rule {
         forall {
           assuming :base
@@ -38,14 +35,12 @@ describe Wongi::Engine::AssumingClause do
       }
     }
 
-    expect( &f ).to raise_error Wongi::Engine::UndefinedBaseRule
-
+    expect(&f).to raise_error Wongi::Engine::UndefinedBaseRule
   end
 
   it 'should come first in a rule' do
-
-    f = -> {
-      engine << rule( :base ) {
+    f = lambda {
+      engine << rule(:base) {
         forall {
           has :x, :y, :Z
         }
@@ -59,8 +54,6 @@ describe Wongi::Engine::AssumingClause do
       }
     }
 
-    expect( &f ).to raise_error Wongi::Engine::DefinitionError
-    
+    expect(&f).to raise_error Wongi::Engine::DefinitionError
   end
-
 end