wongi-engine 0.3.6 → 0.3.7

data/spec/filter_specs/less_test_spec.rb

@@ -1,31 +1,22 @@
 require 'spec_helper'
 
 describe "LESS test" do
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
+  attr_reader :production
 
-  def production
-    @production
-  end
-
-  def test_rule &block
-    @production = ( engine << rule( 'test-rule', &block ) )
+  def test_rule(&block)
+    @production = (engine << rule('test-rule', &block))
   end
 
   it "should interact with optional node correctly" do
-
     # before the fix, filters would try to piggy-back on optional templates
 
     test_rule {
       forall {
         maybe "Z", "Z", "Z"
-        less 6,4 # this should fail
+        less 6, 4 # this should fail
       }
 
       make {
@@ -33,9 +24,8 @@ describe "LESS test" do
       }
     }
 
-    engine << ["A", "B", "C"]
+    engine << %w[A B C]
 
     expect(@production.size).to eq(0)
   end
-
 end

data/spec/filter_specs/less_than_equality_test_spec.rb

@@ -3,11 +3,8 @@
 require 'spec_helper'
 
 describe 'Less Than Or Equal test' do
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  attr_reader :engine
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   attr_reader :production
 
@@ -27,7 +24,7 @@ describe 'Less Than Or Equal test' do
 
     engine << [5, :assign_check, nil]
     engine << [6, :assign_check, nil]
-    engine << [7, :assign_check, nil] #should not pass
+    engine << [7, :assign_check, nil] # should not pass
     expect(@production.size).to eq(2)
   end
 end

data/spec/generation_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe Wongi::Engine::DSL::Action::StatementGenerator do
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
-  let( :engine ) { Wongi::Engine.create }
-
-  let( :transitive_rule ) {
+  let(:transitive_rule) {
     rule {
       forall {
         has :P, :transitive, true
@@ -17,100 +17,91 @@ describe Wongi::Engine::DSL::Action::StatementGenerator do
     }
   }
 
-  let( :production ) { engine << transitive_rule }
+  let(:production) { engine << transitive_rule }
 
   shared_examples 'generation' do
-
     it 'should generate facts' do
-      engine << %w( Alice relative Bob )
-      engine << %w( Bob relative Dwight )
+      engine << %w[Alice relative Bob]
+      engine << %w[Bob relative Dwight]
 
-      expect( production ).to have(1).token
-      expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+      expect(production).to have(1).token
+      expect(engine.find(*%w[Alice relative Dwight])).not_to be_nil
     end
 
     it 'should retrct generated facts' do
-      engine << %w( Alice relative Bob )
-      engine << %w( Bob relative Dwight )
-      engine.retract %w( Bob relative Dwight )
+      engine << %w[Alice relative Bob]
+      engine << %w[Bob relative Dwight]
+      engine.retract %w[Bob relative Dwight]
 
-      expect( production ).to have(0).tokens
-      expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+      expect(production).to have(0).tokens
+      expect(engine.find(*%w[Alice relative Dwight])).to be_nil
     end
 
     context 'transitive diamond' do
-
-      before :each do
-        engine << %w( Alice relative Bob )
-        engine << %w( Bob relative Dwight )
-        engine << %w( Alice relative Claire )
-        engine << %w( Claire relative Dwight )
+      before do
+        engine << %w[Alice relative Bob]
+        engine << %w[Bob relative Dwight]
+        engine << %w[Alice relative Claire]
+        engine << %w[Claire relative Dwight]
       end
 
       it 'should be created' do
-        expect( production ).to have(2).tokens
-        expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+        expect(production).to have(2).tokens
+        expect(engine.find(*%w[Alice relative Dwight])).not_to be_nil
       end
 
       it 'should remain after a single retraction' do
-        engine.retract %w( Claire relative Dwight )
+        engine.retract %w[Claire relative Dwight]
 
-        expect( production ).to have(1).token
-        expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+        expect(production).to have(1).token
+        expect(engine.find(*%w[Alice relative Dwight])).not_to be_nil
       end
 
       it 'should be destroyed after both retractions' do
-        engine.retract %w( Claire relative Dwight )
-        engine.retract %w( Alice relative Bob )
+        engine.retract %w[Claire relative Dwight]
+        engine.retract %w[Alice relative Bob]
 
-        expect( production ).to have(0).tokens
-        expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+        expect(production).to have(0).tokens
+        expect(engine.find(*%w[Alice relative Dwight])).to be_nil
       end
-
     end
-
   end
 
   context "pre-asserted", :pre do
-
-    before :each do
-      engine << [ "relative", :transitive, true ]
+    before do
+      engine << ["relative", :transitive, true]
     end
 
     it_behaves_like 'generation'
-
   end
 
   context "post-asserted", :post do
-
-    before :each do
+    before do
       production
-      engine << [ "relative", :transitive, true ]
+      engine << ["relative", :transitive, true]
     end
 
     it_behaves_like 'generation'
 
     it 'should not retract generated facts marked as manual', :wip do
-      engine << %w( Alice relative Bob )
-      engine << %w( Bob relative Dwight )
-      engine << %w( Alice relative Dwight )
-      engine.retract %w( Alice relative Bob )
+      engine << %w[Alice relative Bob]
+      engine << %w[Bob relative Dwight]
+      engine << %w[Alice relative Dwight]
+      engine.retract %w[Alice relative Bob]
 
-      expect( production ).to have(0).tokens
-      expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+      expect(production).to have(0).tokens
+      expect(engine.find(*%w[Alice relative Dwight])).not_to be_nil
     end
 
     it 'should retract generated facts unmarked as manual', :wip do
-      engine << %w( Alice relative Bob )
-      engine << %w( Bob relative Dwight )
-      engine << %w( Alice relative Dwight )
-      engine.retract %w( Alice relative Dwight )
-      engine.retract %w( Alice relative Bob )
-
-      expect( production ).to have(0).tokens
-      expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+      engine << %w[Alice relative Bob]
+      engine << %w[Bob relative Dwight]
+      engine << %w[Alice relative Dwight]
+      engine.retract %w[Alice relative Dwight]
+      engine.retract %w[Alice relative Bob]
+
+      expect(production).to have(0).tokens
+      expect(engine.find(*%w[Alice relative Dwight])).to be_nil
     end
-
   end
-
 end

data/spec/high_level_spec.rb

@@ -1,30 +1,22 @@
 require 'spec_helper'
 
-include Wongi::Engine::DSL
-
-dsl {
-
-  section :make
-  clause :test_collector
-  action Wongi::Engine::DSL::Action::SimpleCollector.collector
-
-}
+class << self
+  extend Wongi::Engine::DSL
+
+  dsl {
+    section :make
+    clause :test_collector
+    action Wongi::Engine::DSL::Action::SimpleCollector.collector
+  }
+end
 
 describe 'the engine' do
-
-  before :each do
-    @rete = Wongi::Engine::Network.new
-  end
-
-  def rete
-    @rete
-  end
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   context 'with a simple generative positive rule' do
-
     it 'should generate wmes with an existing rule' do
-
-      rete << rule('symmetric') {
+      engine << rule('symmetric') {
         forall {
           has :P, "symmetric", true
           has :A, :P, :B
@@ -34,23 +26,22 @@ describe 'the engine' do
         }
       }
 
-      rete << Wongi::Engine::WME.new( "friend", "symmetric", true )
-      rete << Wongi::Engine::WME.new( "Alice", "friend", "Bob" )
-      
-      expect(rete.facts.to_a.length).to eq(3)
-      expect(rete.facts.select( &:manual? ).length).to eq(2)
-      generated = rete.facts.find( &:generated? )
-      expect( generated ).to be == Wongi::Engine::WME.new( "Bob", "friend", "Alice" )
+      engine << Wongi::Engine::WME.new("friend", "symmetric", true)
+      engine << Wongi::Engine::WME.new("Alice", "friend", "Bob")
+
+      expect(engine.facts.to_a.length).to eq(3)
+      expect(engine.facts.select(&:manual?).length).to eq(2)
+      generated = engine.facts.find(&:generated?)
+      expect(generated).to be == Wongi::Engine::WME.new("Bob", "friend", "Alice")
     end
 
     it 'should generate wmes with an added rule' do
+      engine << Wongi::Engine::WME.new("friend", "symmetric", true)
+      engine << Wongi::Engine::WME.new("Alice", "friend", "Bob")
 
-      rete << Wongi::Engine::WME.new( "friend", "symmetric", true )
-      rete << Wongi::Engine::WME.new( "Alice", "friend", "Bob" )
-
-      expect(rete.facts.to_a.length).to eq(2)
+      expect(engine.facts.to_a.length).to eq(2)
 
-      rete << rule('symmetric') {
+      engine << rule('symmetric') {
         forall {
           has :P, "symmetric", true
           has :A, :P, :B
@@ -60,13 +51,12 @@ describe 'the engine' do
         }
       }
 
-      expect(rete.facts.to_a.length).to eq(3)
-      expect(rete.facts.select( &:manual? ).size).to eq(2)
+      expect(engine.facts.to_a.length).to eq(3)
+      expect(engine.facts.select(&:manual?).size).to eq(2)
     end
 
     it 'should not get confused by recursive activations' do
-
-      rete << rule('reflexive') {
+      engine << rule('reflexive') {
         forall {
           has :Predicate, "reflexive", true
           has :X, :Predicate, :Y
@@ -77,37 +67,29 @@ describe 'the engine' do
         }
       }
 
-      rete << [:p, "reflexive", true]
-      rete << [:x, :p, :y]
-
-      expect(rete.wmes.to_a.length).to eq(4)
-      expect(rete.select(:x, :p, :x).length).to eq(1)
-      expect(rete.select(:y, :p, :y).length).to eq(1)
+      engine << [:p, "reflexive", true]
+      engine << %i[x p y]
 
+      expect(engine.wmes.to_a.length).to eq(4)
+      expect(engine.select(:x, :p, :x).length).to eq(1)
+      expect(engine.select(:y, :p, :y).length).to eq(1)
     end
-
   end
 
   it 'should check equality' do
-
-    node = rete << rule('equality') {
+    node = engine << rule('equality') {
       forall {
         fact :A, "same", :B
         same :A, :B
       }
-      make {
-
-      }
     }
 
-    rete << [ 42, "same", 42 ]
+    engine << [42, "same", 42]
     expect(node.size).to eq(1)
-
   end
 
   it 'should compare things' do
-
-    rete << rule('less') {
+    engine << rule('less') {
       forall {
         has :A, :age, :N1
         has :B, :age, :N2
@@ -118,7 +100,7 @@ describe 'the engine' do
       }
     }
 
-    rete << rule('less') {
+    engine << rule('less') {
       forall {
         has :A, :age, :N1
         has :B, :age, :N2
@@ -129,20 +111,18 @@ describe 'the engine' do
       }
     }
 
-    rete << ["Alice", :age, 42]
-    rete << ["Bob", :age, 43]
+    engine << ["Alice", :age, 42]
+    engine << ["Bob", :age, 43]
 
-    items = rete.select "Alice", :younger, "Bob"
+    items = engine.select "Alice", :younger, "Bob"
     expect(items.size).to eq(1)
 
-    items = rete.select "Bob", :older, "Alice"
+    items = engine.select "Bob", :older, "Alice"
     expect(items.size).to eq(1)
-
   end
 
   it 'should use collectors' do
-
-    rete << rule('collector') {
+    engine << rule('collector') {
       forall {
         has :X, :_, 42
       }
@@ -151,17 +131,16 @@ describe 'the engine' do
       }
     }
 
-    rete << [ "answer", "is", 42 ]
-    rete << [ "question", "is", -1 ]
+    engine << ["answer", "is", 42]
+    engine << ["question", "is", -1]
 
-    collection = rete.collection(:test_collector)
+    collection = engine.collection(:test_collector)
     expect(collection.size).to eq(1)
     expect(collection.first).to eq("answer")
-
   end
 
   it "should properly show error messages" do
-    rete << rule("Error rule") {
+    engine << rule("Error rule") {
       forall {
         has :_, :_, :TestNumber
         greater :TestNumber, 0
@@ -171,15 +150,14 @@ describe 'the engine' do
       }
     }
 
-    rete << [ "A", "B", 1 ]
+    engine << ["A", "B", 1]
 
-    error_messages = rete.errors.map(&:message)
+    error_messages = engine.errors.map(&:message)
     expect(error_messages).to eq(["An error has occurred"])
   end
 
   it 'should use generic collectors' do
-
-    rete << rule('generic-collector') {
+    engine << rule('generic-collector') {
       forall {
         has :X, :_, 42
       }
@@ -188,20 +166,17 @@ describe 'the engine' do
       }
     }
 
-    rete << [ "answer", "is", 42 ]
-    rete << [ "question", "is", -1 ]
+    engine << ["answer", "is", 42]
+    engine << ["question", "is", -1]
 
-    collection = rete.collection(:things_that_are_42)
+    collection = engine.collection(:things_that_are_42)
     expect(collection.size).to eq(1)
     expect(collection.first).to eq("answer")
-
   end
 
   it 'should accept several rules' do
-
     expect {
-
-      rete << rule('generic-collector') {
+      engine << rule('generic-collector') {
         forall {
           has :X, :_, 42
         }
@@ -210,7 +185,7 @@ describe 'the engine' do
         }
       }
 
-      rete << rule('collector') {
+      engine << rule('collector') {
         forall {
           has :X, :_, 42
         }
@@ -218,31 +193,26 @@ describe 'the engine' do
           test_collector :X
         }
       }
-
     }.not_to raise_error
-
   end
 
   it 'should process negative nodes' do
-
-    production = (rete << rule('negative') {
-      forall {
-        neg :_, :_, 42
-      }
-      })
+    production = (engine << rule('negative') {
+                    forall {
+                      neg :_, :_, 42
+                    }
+                  })
 
     expect(production.size).to eq(1)
 
-    rete << [ "answer", "is", 42 ]
+    engine << ["answer", "is", 42]
 
     expect(production.size).to eq(0)
-
   end
 
   context 'queries' do
-
-    before :each do
-      rete << query("test-query") {
+    before do
+      engine << query("test-query") {
         search_on :X
         forall {
           has :X, "is", :Y
@@ -251,32 +221,25 @@ describe 'the engine' do
     end
 
     it 'should run' do
-      rete << ["answer", "is", 42]
-      rete.execute "test-query", {X: "answer"}
-      expect(rete.results["test-query"].size).to eq(1)
-      expect(rete.results["test-query"].tokens.first[:Y]).to eq(42)
+      engine << ["answer", "is", 42]
+      engine.execute "test-query", { X: "answer" }
+      expect(engine.results["test-query"].size).to eq(1)
+      expect(engine.results["test-query"].tokens.first[:Y]).to eq(42)
     end
 
     it 'should run several times' do
-      rete << ["answer", "is", 42]
-      rete << ['question', 'is', '6x9']
-      rete.execute "test-query", {X: "answer"}
-      rete.execute "test-query", {X: "question"}
-      expect(rete.results["test-query"].tokens.to_a.last[:Y]).to eq('6x9')
-      expect(rete.results["test-query"].size).to eq(1)
+      engine << ["answer", "is", 42]
+      engine << %w[question is 6x9]
+      engine.execute "test-query", { X: "answer" }
+      engine.execute "test-query", { X: "question" }
+      expect(engine.results["test-query"].tokens.to_a.last[:Y]).to eq('6x9')
+      expect(engine.results["test-query"].size).to eq(1)
     end
-
   end
 
-  it 'should correctly execute a query several times' do
-
-  end
-  
   context 'with timelines' do
-
     it 'should not match with no past point' do
-
-      production = rete.rule {
+      production = engine.rule {
         forall {
           has 1, 2, 3, time: -1
         }
@@ -284,95 +247,86 @@ describe 'the engine' do
 
       expect(production.size).to eq(0)
 
-      rete << [1, 2, 3]
+      engine << [1, 2, 3]
 
       expect(production.size).to eq(0)
-
     end
 
     it 'should match a simple past point' do
-
-      production = rete.rule {
+      production = engine.rule {
         forall {
           has 1, 2, 3, time: -1
         }
       }
 
-      rete << [1, 2, 3]
-      rete.snapshot!
+      engine << [1, 2, 3]
+      engine.snapshot!
 
       expect(production.size).to eq(1)
-
     end
 
     context 'using the :asserted clause' do
-
       it 'should match asserted items' do
         count = 0
-        production = rete.rule do
+        production = engine.rule do
           forall {
             asserted 1, 2, 3
           }
-          make { action { count += 1} }
+          make { action { count += 1 } }
         end
         expect(production.size).to eq(0)
-        rete.snapshot!
-        rete << [1, 2, 3]
+        engine.snapshot!
+        engine << [1, 2, 3]
         expect(production.size).to eq(1)
-        #puts count
+        # puts count
       end
 
       it 'should not match kept items' do
         count = 0
-        production = rete.rule do
+        production = engine.rule do
           forall {
             asserted 1, 2, 3
           }
-          make { action { count += 1} }
+          make { action { count += 1 } }
         end
-        rete << [1, 2, 3]
+        engine << [1, 2, 3]
         expect(production.size).to eq(1)
-        rete.snapshot!
+        engine.snapshot!
         expect(production.size).to eq(0)
-        #puts count
+        # puts count
       end
-
     end
 
     context 'using the :kept clause' do
-
       it 'should match kept items' do
         count = 0
-        production = rete.rule do
+        production = engine.rule do
           forall {
             kept 1, 2, 3
           }
-          make { action { count += 1} }
+          make { action { count += 1 } }
         end
-        rete << [1, 2, 3]
+        engine << [1, 2, 3]
         expect(production.size).to eq(0)
-        rete.snapshot!
+        engine.snapshot!
         expect(production.size).to eq(1)
-        #puts count
+        # puts count
       end
 
       it 'should not match asserted wmes' do
         count = 0
-        production = rete.rule do
+        production = engine.rule do
           forall {
             kept 1, 2, 3
           }
-          make { action { count += 1} }
+          make { action { count += 1 } }
         end
         expect(production.size).to eq(0)
-        rete.snapshot!
-        rete << [1, 2, 3]
+        engine.snapshot!
+        engine << [1, 2, 3]
         expect(production.size).to eq(0)
-        #puts count
+        # puts count
       end
-
     end
-
   end
-
 end