wongi-engine 0.3.6 → 0.3.7

data/spec/rule_specs/maybe_rule_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
 
 describe "MAYBE rule" do
-
-  let( :engine ) { Wongi::Engine.create }
-  let( :maybe_rule ) {
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
+  let(:maybe_rule) {
     rule {
       forall {
         has 1, 2, :X
@@ -13,7 +13,6 @@ describe "MAYBE rule" do
   }
 
   it "should pass with existing facts" do
-
     production = engine << maybe_rule
 
     engine << [1, 2, 3]
@@ -23,11 +22,9 @@ describe "MAYBE rule" do
 
     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]
@@ -36,11 +33,9 @@ describe "MAYBE rule" do
 
     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
@@ -49,11 +44,9 @@ describe "MAYBE rule" do
 
     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]
@@ -64,11 +57,9 @@ describe "MAYBE rule" do
 
     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]
@@ -84,7 +75,6 @@ describe "MAYBE rule" do
       expect(prod.size).to eq(1)
       expect(prod.tokens.first[:Y]).to be_nil
     }
-
   end
 
   it 'should handle retracted parent tokens' do
@@ -95,7 +85,6 @@ describe "MAYBE rule" do
     engine.retract [1, 2, 3]
 
     expect(prod).to have(0).tokens
-    expect(engine.find(3,4,5).opt_join_results).to be_empty
+    expect(engine.find(3, 4, 5).opt_join_results).to be_empty
   end
-
 end

data/spec/rule_specs/ncc_spec.rb

@@ -1,14 +1,8 @@
 require 'spec_helper'
 
 describe Wongi::Engine::NccNode do
-
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   def ncc_rule
     rule('ncc') {
@@ -36,7 +30,6 @@ describe Wongi::Engine::NccNode do
   end
 
   it 'should pass with a mismatching subchain' do
-
     engine << ncc_rule
     production = engine.productions['ncc']
 
@@ -51,11 +44,9 @@ describe Wongi::Engine::NccNode do
     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']
 
@@ -66,15 +57,13 @@ describe Wongi::Engine::NccNode do
     expect(production).to have(0).tokens
 
     engine.retract [3, 4, 5]
-    expect( production ).to have(1).token
+    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']
@@ -83,30 +72,28 @@ describe Wongi::Engine::NccNode do
     engine << [1, 2, 3]
     engine << [3, 4, 5]
 
-    expect( production ).to have(0).tokens
+    expect(production).to have(0).tokens
 
     engine.retract [3, 4, 5]
-    expect( production ).to have(1).tokens
+    expect(production).to have(1).tokens
 
     engine.retract ["base", "is", 1]
-    expect( production ).to have(0).tokens
-
+    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
+        # trace values: true, generation: true
         gen rule.name, :light_bathroom, :on
         gen rule.name, :want_action_for, :light_bathroom
       }
     end
 
-    prod = engine.rule "action" do
+    engine.rule "action" do
       forall {
         has :Requestor, :want_action_for, :Actor
         has :Requestor, :Actor, :Value
@@ -119,7 +106,7 @@ describe Wongi::Engine::NccNode do
         }
       }
       make {
-        #trace values: true, generation: true
+        # trace values: true, generation: true
         gen :Actor, :value, :Value
         gen :Actor, :last_user, :Requestor
       }
@@ -130,41 +117,39 @@ describe Wongi::Engine::NccNode do
     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 << %i[user want_action_for light_bathroom]
+    engine << %i[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 << %i[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) ]
+    engine << %i[poweruser want_action_for light_bathroom]
+    engine << %i[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 << %i[god want_action_for light_bathroom]
+    engine << %i[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
+        # trace values: true, generation: true
         gen rule.name, :light_bathroom, :on
         gen rule.name, :want_action_for, :light_bathroom
       }
     end
 
-    prod = engine.rule "action" do
+    engine.rule "action" do
       forall {
         has :Requestor, :want_action_for, :Actor
         has :Requestor, :Actor, :Value
@@ -177,7 +162,7 @@ describe Wongi::Engine::NccNode do
         }
       }
       make {
-        #trace values: true, generation: true
+        # trace values: true, generation: true
         gen :Actor, :value, :Value
         gen :Actor, :last_user, :Requestor
       }
@@ -188,25 +173,24 @@ describe Wongi::Engine::NccNode do
     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 << %i[user want_action_for light_bathroom]
+    engine << %i[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 << %i[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) ]
+    engine << %i[poweruser want_action_for light_bathroom]
+    engine << %i[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 << %i[god want_action_for light_bathroom]
+    engine << %i[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
@@ -233,9 +217,9 @@ describe Wongi::Engine::NccNode do
       }
     }
 
-    %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 ]
+    %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]
@@ -250,9 +234,9 @@ describe Wongi::Engine::NccNode do
     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
+    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
 
   specify 'regression #71' do
@@ -270,5 +254,4 @@ describe Wongi::Engine::NccNode do
 
     expect(prod).to have(1).tokens
   end
-
 end

data/spec/rule_specs/negative_rule_spec.rb

@@ -1,19 +1,11 @@
 require 'spec_helper'
 
 describe "negative rule" do
-
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   it "should not introduce variables" do
-
     proc = lambda {
-
       engine << rule('one-option') {
         forall {
           neg :Foo, :bar, :_
@@ -24,15 +16,12 @@ describe "negative rule" do
           }
         }
       }
-
     }
 
-    expect( &proc ).to raise_error( Wongi::Engine::DefinitionError )
-
+    expect(&proc).to raise_error(Wongi::Engine::DefinitionError)
   end
 
   specify "variable example 1" do
-
     prod = engine << rule {
       forall {
         has :x, :y, :Z
@@ -41,15 +30,13 @@ describe "negative rule" do
     }
 
     engine << [:x, :y, 1]
-    expect( prod ).to have(1).tokens
+    expect(prod).to have(1).tokens
 
     engine << [:a, :b, 1]
-    expect( prod ).to have(0).tokens
-
+    expect(prod).to have(0).tokens
   end
 
   specify "variable example 1" do
-
     prod = engine << rule {
       forall {
         has :x, :y, :Z
@@ -59,11 +46,10 @@ describe "negative rule" do
 
     engine << [:a, :b, 1]
     engine << [:x, :y, 1]
-    expect( prod ).to have(0).tokens
+    expect(prod).to have(0).tokens
 
     engine.retract [:a, :b, 1]
-    expect( prod ).to have(1).tokens
-
+    expect(prod).to have(1).tokens
   end
 
   # it "should not create infinite feedback loops by default" do
@@ -82,9 +68,8 @@ describe "negative rule" do
   # end
 
   it "should create infinite feedback loops with unsafe option" do
-
     counter = 0
-    exception = Class.new( StandardError )
+    exception = Class.new(StandardError)
 
     proc = lambda {
       engine << rule('feedback') {
@@ -92,14 +77,15 @@ describe "negative rule" do
           neg :a, :b, :_, unsafe: true
         }
         make {
-          action { counter += 1 ; if counter > 5 then raise exception.new end }
+          action {
+            counter += 1
+            raise exception if counter > 5
+          }
           gen :a, :b, :c
         }
       }
     }
 
-    expect( &proc ).to raise_error( exception )
-
+    expect(&proc).to raise_error(exception)
   end
-
 end

data/spec/rule_specs/or_rule_spec.rb

@@ -1,29 +1,21 @@
 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 two options' do
-
     let :production do
       engine << rule do
         forall {
           any {
             option {
               has :A, :path1, :_
-            }    
+            }
             option {
               has :A, :path2, :_
-            }    
+            }
           }
         }
       end
@@ -44,7 +36,5 @@ describe "ANY rule" do
       engine << [:x, :path2, true]
       expect(production.tokens).to have(2).items
     end
-
   end
-
 end

data/spec/ruleset_spec.rb

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

data/spec/simple_action_spec.rb

@@ -1,20 +1,12 @@
 require 'spec_helper'
 
 describe Wongi::Engine::DSL::Action::SimpleAction do
-
-  before :each do
-    @rete = Wongi::Engine::Network.new
-  end
-
-  def rete
-    @rete
-  end
+  let(:engine) { Wongi::Engine.create }
 
   it 'should work with blocks' do
-
     count = 0
 
-    rete.rule do
+    engine.rule do
       forall {
         has 1, 2, :X
       }
@@ -27,14 +19,12 @@ describe Wongi::Engine::DSL::Action::SimpleAction do
 
     expect(count).to eq(0)
 
-    rete << [1, 2, 3]
+    engine << [1, 2, 3]
 
     expect(count).to eq(1)
 
-    rete << [1, 2, 4]
+    engine << [1, 2, 4]
 
     expect(count).to eq(2)
-
   end
-
 end

data/spec/wme_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Wongi::Engine::WME do
-
   # def capitalizing_rete
   #   rete = double 'rete'
   #   expect( rete ).to receive(:import).with("b").and_return("B")
@@ -15,11 +14,10 @@ describe Wongi::Engine::WME do
   }
 
   context 'a new WME' do
-
     it 'should initialize and expose members' do
-      expect( subject.subject ).to be == "a"
-      expect( subject.predicate ).to be == "b"
-      expect( subject.object ).to be == "c"
+      expect(subject.subject).to be == "a"
+      expect(subject.predicate).to be == "b"
+      expect(subject.object).to be == "c"
     end
 
     # it 'should use the rete to import members' do
@@ -34,15 +32,13 @@ describe Wongi::Engine::WME do
 
     # end
 
+    it {
+      should be_manual
+    }
 
-  it {
-    should be_manual
-  }
-
-  it {
-    should_not be_generated
-  }
-
+    it {
+      should_not be_generated
+    }
   end
 
   # it 'should be able to import into rete' do
@@ -58,26 +54,23 @@ describe Wongi::Engine::WME do
   # end
 
   it 'should compare instances' do
-
     wme1 = Wongi::Engine::WME.new "a", "b", "c"
     wme2 = Wongi::Engine::WME.new "a", "b", "c"
     wme3 = Wongi::Engine::WME.new "a", "b", "d"
 
-    expect( wme1 ).to be == wme2
-    expect( wme1 ).not_to be == wme3
-
+    expect(wme1).to be == wme2
+    expect(wme1).not_to be == wme3
   end
 
   it 'should not match against non-templates' do
-    expect { subject =~ [1, 2, 3] }.to raise_error( Wongi::Engine::Error )
+    expect { subject =~ [1, 2, 3] }.to raise_error(Wongi::Engine::Error)
   end
 
   it 'should match against templates' do
     t1 = Wongi::Engine::Template.new "a", :_, :_
     t2 = Wongi::Engine::Template.new "b", :_, :_
 
-    expect( subject ).to be =~ t1
-    expect( subject ).not_to be =~ t2
+    expect(subject).to be =~ t1
+    expect(subject).not_to be =~ t2
   end
-
 end