wongi-engine 0.0.14 → 0.0.16

data/spec/high_level_spec.rb

@@ -34,11 +34,11 @@ describe 'the engine' do
 
       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
+      
+      expect(rete.facts.to_a.length).to eq(3)
+      expect(rete.facts.select( &:manual? ).length).to eq(2)
       generated = rete.facts.find( &:generated? )
-      generated.should == Wongi::Engine::WME.new( "Bob", "friend", "Alice" )
+      expect( generated ).to be == Wongi::Engine::WME.new( "Bob", "friend", "Alice" )
     end
 
     it 'should generate wmes with an added rule' do
@@ -46,7 +46,7 @@ describe 'the engine' do
       rete << Wongi::Engine::WME.new( "friend", "symmetric", true )
       rete << Wongi::Engine::WME.new( "Alice", "friend", "Bob" )
 
-      rete.should have(2).facts
+      expect(rete.facts.to_a.length).to eq(2)
 
       rete << rule('symmetric') {
         forall {
@@ -58,8 +58,8 @@ describe 'the engine' do
         }
       }
 
-      rete.should have(3).facts
-      rete.facts.select( &:manual? ).should have(2).items
+      expect(rete.facts.to_a.length).to eq(3)
+      expect(rete.facts.select( &:manual? ).size).to eq(2)
     end
 
     it 'should not get confused by recursive activations' do
@@ -78,9 +78,9 @@ describe 'the engine' do
       rete << [:p, "reflexive", true]
       rete << [:x, :p, :y]
 
-      expect( rete ).to have(4).wmes
-      expect( rete.select :x, :p, :x ).to have(1).items
-      expect( rete.select :y, :p, :y ).to have(1).items
+      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)
 
     end
 
@@ -99,7 +99,7 @@ describe 'the engine' do
     }
 
     rete << [ 42, "same", 42 ]
-    node.should have(1).tokens
+    expect(node.size).to eq(1)
 
   end
 
@@ -131,10 +131,10 @@ describe 'the engine' do
     rete << ["Bob", :age, 43]
 
     items = rete.select "Alice", :younger, "Bob"
-    items.should have(1).items
+    expect(items.size).to eq(1)
 
     items = rete.select "Bob", :older, "Alice"
-    items.should have(1).items
+    expect(items.size).to eq(1)
 
   end
 
@@ -153,8 +153,8 @@ describe 'the engine' do
     rete << [ "question", "is", -1 ]
 
     collection = rete.collection(:test_collector)
-    collection.should have(1).item
-    collection.first.should == "answer"
+    expect(collection.size).to eq(1)
+    expect(collection.first).to eq("answer")
 
   end
 
@@ -173,14 +173,14 @@ describe 'the engine' do
     rete << [ "question", "is", -1 ]
 
     collection = rete.collection(:things_that_are_42)
-    collection.should have(1).item
-    collection.first.should == "answer"
+    expect(collection.size).to eq(1)
+    expect(collection.first).to eq("answer")
 
   end
 
   it 'should accept several rules' do
 
-    lambda do
+    expect {
 
       rete << rule('generic-collector') {
         forall {
@@ -200,7 +200,7 @@ describe 'the engine' do
         }
       }
 
-    end.should_not raise_error
+    }.not_to raise_error
 
   end
 
@@ -212,11 +212,11 @@ describe 'the engine' do
       }
       })
 
-    production.should have(1).tokens
+    expect(production.size).to eq(1)
 
     rete << [ "answer", "is", 42 ]
 
-    production.should have(0).tokens
+    expect(production.size).to eq(0)
 
   end
 
@@ -232,8 +232,8 @@ describe 'the engine' do
     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
+    expect(rete.results["test-query"].size).to eq(1)
+    expect(rete.results["test-query"].tokens.first[:Y]).to eq(42)
 
   end
   
@@ -247,11 +247,11 @@ describe 'the engine' do
         }
       }
 
-      production.should have(0).tokens
+      expect(production.size).to eq(0)
 
       rete << [1, 2, 3]
 
-      production.should have(0).tokens
+      expect(production.size).to eq(0)
 
     end
 
@@ -266,7 +266,7 @@ describe 'the engine' do
       rete << [1, 2, 3]
       rete.snapshot!
 
-      production.should have(1).tokens
+      expect(production.size).to eq(1)
 
     end
 
@@ -280,10 +280,10 @@ describe 'the engine' do
           }
           make { action { count += 1} }
         end
-        production.should have(0).tokens
+        expect(production.size).to eq(0)
         rete.snapshot!
         rete << [1, 2, 3]
-        production.should have(1).tokens
+        expect(production.size).to eq(1)
         #puts count
       end
 
@@ -296,9 +296,9 @@ describe 'the engine' do
           make { action { count += 1} }
         end
         rete << [1, 2, 3]
-        production.should have(1).tokens
+        expect(production.size).to eq(1)
         rete.snapshot!
-        production.should have(0).tokens
+        expect(production.size).to eq(0)
         #puts count
       end
 
@@ -315,9 +315,9 @@ describe 'the engine' do
           make { action { count += 1} }
         end
         rete << [1, 2, 3]
-        production.should have(0).tokens
+        expect(production.size).to eq(0)
         rete.snapshot!
-        production.should have(1).tokens
+        expect(production.size).to eq(1)
         #puts count
       end
 
@@ -329,10 +329,10 @@ describe 'the engine' do
           }
           make { action { count += 1} }
         end
-        production.should have(0).tokens
+        expect(production.size).to eq(0)
         rete.snapshot!
         rete << [1, 2, 3]
-        production.should have(0).tokens
+        expect(production.size).to eq(0)
         #puts count
       end
 

data/spec/rule_specs/any_rule_spec.rb

@@ -30,7 +30,7 @@ describe "ANY rule" do
         engine << [1, 2, 3]
         engine << [3, 4, 5]
 
-        production.should have(1).tokens
+        expect(production.size).to eq(1)
 
       end
 
@@ -64,9 +64,9 @@ describe "ANY rule" do
         engine << [1, 2, "three"]
         engine << ["three", "four", "five"]
 
-        production.should have(2).tokens
-        engine.collection(:threes).should include(3)
-        engine.collection(:threes).should include("three")
+        expect(production.size).to eq(2)
+        expect( engine.collection(:threes) ).to include(3)
+        expect( engine.collection(:threes) ).to include("three")
 
       end
 

data/spec/rule_specs/assign_spec.rb

@@ -27,9 +27,8 @@ describe "ASSIGN rule" do
         end
       }
     }
-
-    production.should have(1).tokens
-    production.tokens.first[:X].should == 42
+    expect(production.size).to eq(1)
+    expect(production.tokens.first[:X]).to eq(42)
 
   end
 
@@ -45,7 +44,7 @@ describe "ASSIGN rule" do
     }
 
     engine << [1, 2, 5]
-    production.tokens.first[:Y].should == 10
+    expect(production.tokens.first[:Y]).to eq(10)
 
   end
 

data/spec/rule_specs/maybe_rule_spec.rb

@@ -19,15 +19,15 @@ describe "MAYBE rule" do
       }
     end
 
-    prod = engine.productions['test']
+    production = engine.productions['test']
 
     engine << [1, 2, 3]
     engine << [3, 4, 5]
 
-    prod.should have(1).tokens
+    expect(production.size).to eq(1)
 
-    prod.tokens.first[:X].should == 3
-    prod.tokens.first[:Y].should == 5
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to eq(5)
 
   end
 
@@ -40,14 +40,14 @@ describe "MAYBE rule" do
       }
     end
 
-    prod = engine.productions['test']
+    production = engine.productions['test']
 
     engine << [1, 2, 3]
 
-    prod.should have(1).tokens
+    expect(production.size).to eq(1)
 
-    prod.tokens.first[:X].should == 3
-    prod.tokens.first[:Y].should be_nil
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to be_nil
 
   end
 
@@ -62,12 +62,12 @@ describe "MAYBE rule" do
       }
     end
 
-    prod = engine.productions['test']
+    production = engine.productions['test']
 
-    prod.should have(1).tokens
+    expect(production.size).to eq(1)
 
-    prod.tokens.first[:X].should == 3
-    prod.tokens.first[:Y].should be_nil
+    expect(production.tokens.first[:X]).to eq(3)
+    expect(production.tokens.first[:Y]).to be_nil
 
   end
 

data/spec/rule_specs/ncc_spec.rb

@@ -29,15 +29,15 @@ describe "NCC rule" do
 
     engine << ["base", "is", 1]
 
-    production.should have(1).tokens
+    expect(production.size).to eq(1)
 
     engine << [1, 2, 3]
 
-    production.should have(1).tokens
+    expect(production.size).to eq(1)
 
     engine << [3, 4, 5]
 
-    production.should have(0).tokens
+    expect(production.size).to eq(0)
 
   end
 
@@ -50,13 +50,13 @@ describe "NCC rule" do
     engine << [1, 2, 3]
     engine << [3, 4, 5]
 
-    production.should have(0).tokens
+    expect(production.size).to eq(0)
 
     engine.retract [3, 4, 5]
-    production.should have(1).tokens
+    expect( production ).to have(1).token
 
     engine.retract ["base", "is", 1]
-    production.should have(0).tokens
+    expect(production.size).to eq(0)
 
   end
 

data/spec/rule_specs/negative_rule_spec.rb

@@ -1,70 +1,70 @@
-require 'spec_helper'
-
-describe "negative rule" do
-
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
-
-  it "should not introduce variables" do
-
-    proc = lambda {
-
-      engine << rule('one-option') {
-        forall {
-          neg :Foo, :bar, :_
-        }
-        make {
-          action { |tokens|
-            raise "This should never get executed #{tokens}"
-          }
-        }
-      }
-
-    }
-
-    proc.should raise_error( Wongi::Engine::DefinitionError )
-
-  end
-
-  # it "should not create infinite feedback loops by default" do
-
-  #   engine << rule('feedback') {
-  #     forall {
-  #       neg :a, :b, :_
-  #     }
-  #     make {
-  #       gen :a, :b, :c
-  #     }
-  #   }
-
-  #   engine.should have(1).facts
-
-  # end
-
-  it "should create infinite feedback loops with unsafe option" do
-
-    counter = 0
-    exception = Class.new( StandardError )
-
-    proc = lambda {
-      engine << rule('feedback') {
-        forall {
-          neg :a, :b, :_, unsafe: true
-        }
-        make {
-          action { counter += 1 ; if counter > 5 then raise exception.new end }
-          gen :a, :b, :c
-        }
-      }
-    }
-
-    proc.should raise_error( exception )
-
-  end
-
-end
+require 'spec_helper'
+
+describe "negative rule" do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  it "should not introduce variables" do
+
+    proc = lambda {
+
+      engine << rule('one-option') {
+        forall {
+          neg :Foo, :bar, :_
+        }
+        make {
+          action { |tokens|
+            raise "This should never get executed #{tokens}"
+          }
+        }
+      }
+
+    }
+
+    expect( &proc ).to raise_error( Wongi::Engine::DefinitionError )
+
+  end
+
+  # it "should not create infinite feedback loops by default" do
+
+  #   engine << rule('feedback') {
+  #     forall {
+  #       neg :a, :b, :_
+  #     }
+  #     make {
+  #       gen :a, :b, :c
+  #     }
+  #   }
+
+  #   engine.should have(1).facts
+
+  # end
+
+  it "should create infinite feedback loops with unsafe option" do
+
+    counter = 0
+    exception = Class.new( StandardError )
+
+    proc = lambda {
+      engine << rule('feedback') {
+        forall {
+          neg :a, :b, :_, unsafe: true
+        }
+        make {
+          action { counter += 1 ; if counter > 5 then raise exception.new end }
+          gen :a, :b, :c
+        }
+      }
+    }
+
+    expect( &proc ).to raise_error( exception )
+
+  end
+
+end

data/spec/ruleset_spec.rb

@@ -9,7 +9,7 @@ describe Wongi::Engine::Ruleset do
   context 'initially' do
 
     it 'should have no rules' do
-      Wongi::Engine::Ruleset.rulesets.should be_empty
+      expect( Wongi::Engine::Ruleset.rulesets ).to be_empty
     end
 
   end
@@ -18,19 +18,19 @@ describe Wongi::Engine::Ruleset 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
+      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'
-      ruleset.name.should == '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'
-      Wongi::Engine::Ruleset.rulesets.should_not be_empty
-      Wongi::Engine::Ruleset[ruleset.name].should == ruleset
+      expect( Wongi::Engine::Ruleset.rulesets ).not_to be_empty
+      expect( Wongi::Engine::Ruleset[ruleset.name] ).to be == ruleset
     end
 
   end
@@ -38,7 +38,7 @@ describe Wongi::Engine::Ruleset do
   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
+    expect( Wongi::Engine::Ruleset.rulesets ).to be_empty
   end
 
   it 'should install creating rules into a rete' do
@@ -47,7 +47,7 @@ describe Wongi::Engine::Ruleset do
     ruleset = Wongi::Engine::Ruleset.new
     rule = ruleset.rule( 'test-rule' ) { }
 
-    rete.should_receive(:<<).with(rule).once
+    expect( rete ).to receive(:<<).with(rule).once
     ruleset.install rete
   end
 

data/spec/simple_action_spec.rb

@@ -25,15 +25,15 @@ describe Wongi::Engine::SimpleAction do
       }
     end
 
-    count.should == 0
+    expect(count).to eq(0)
 
     rete << [1, 2, 3]
 
-    count.should == 1
+    expect(count).to eq(1)
 
     rete << [1, 2, 4]
 
-    count.should == 2
+    expect(count).to eq(2)
 
   end
 

data/spec/spec_helper.rb

@@ -1 +1,3 @@
 require 'wongi-engine'
+require 'rspec/collection_matchers'
+require 'pry'

data/spec/wme_spec.rb

@@ -4,9 +4,9 @@ describe Wongi::Engine::WME do
 
   def capitalizing_rete
     rete = double 'rete'
-    rete.should_receive(:import).with("a").and_return("A")
-    rete.should_receive(:import).with("b").and_return("B")
-    rete.should_receive(:import).with("c").and_return("C")
+    expect( rete ).to receive(:import).with("b").and_return("B")
+    expect( rete ).to receive(:import).with("a").and_return("A")
+    expect( rete ).to receive(:import).with("c").and_return("C")
     rete
   end
 
@@ -17,9 +17,9 @@ describe Wongi::Engine::WME do
   context 'a new WME' do
 
     it 'should initialize and expose members' do
-      subject.subject.should == "a"
-      subject.predicate.should == "b"
-      subject.object.should == "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
@@ -28,19 +28,19 @@ describe Wongi::Engine::WME do
 
       wme = Wongi::Engine::WME.new "a", "b", "c", rete
 
-      wme.subject.should == "A"
-      wme.predicate.should == "B"
-      wme.object.should == "C"
+      expect( wme.subject ).to be == "A"
+      expect( wme.predicate ).to be == "B"
+      expect( wme.object ).to be == "C"
 
     end
 
 
-  specify {
-    subject.should be_manual
+  it {
+    should be_manual
   }
 
-  specify {
-    subject.should_not be_generated
+  it {
+    should_not be_generated
   }
 
   end
@@ -51,9 +51,9 @@ describe Wongi::Engine::WME do
 
     imported = subject.import_into rete
 
-    imported.subject.should == "A"
-    imported.predicate.should == "B"
-    imported.object.should == "C"
+    expect( imported.subject ).to be == "A"
+    expect( imported.predicate ).to be == "B"
+    expect( imported.object ).to be == "C"
 
   end
 
@@ -63,21 +63,21 @@ describe Wongi::Engine::WME do
     wme2 = Wongi::Engine::WME.new "a", "b", "c"
     wme3 = Wongi::Engine::WME.new "a", "b", "d"
 
-    wme1.should == wme2
-    wme1.should_not == wme3
+    expect( wme1 ).to be == wme2
+    expect( wme1 ).not_to be == wme3
 
   end
 
   it 'should not match against non-templates' do
-    lambda { subject =~ [1, 2, 3] }.should raise_error
+    expect { subject =~ [1, 2, 3] }.to raise_error
   end
 
   it 'should match against templates' do
     t1 = Wongi::Engine::Template.new "a", :_, :_
     t2 = Wongi::Engine::Template.new "b", :_, :_
 
-    subject.should =~ t1
-    subject.should_not =~ t2
+    expect( subject ).to be =~ t1
+    expect( subject ).not_to be =~ t2
   end
 
 end

data/wongi-engine.gemspec

@@ -5,8 +5,9 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Valeri Sokolov"]
   gem.email         = ["ulfurinn@ulfurinn.net"]
   gem.description   = %q{A rule engine.}
-  gem.summary       = %q{A rule engine.}
+  gem.summary       = %q{A forward-chaining rule engine in pure Ruby.}
   gem.homepage      = "https://github.com/ulfurinn/wongi-engine"
+  gem.licenses      = %w(MIT)
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -15,5 +16,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Wongi::Engine::VERSION
 
-  gem.add_development_dependency 'rspec', '~> 2.14.1', '< 3.0.0'
+  gem.add_development_dependency 'rake', '~> 10'
+  gem.add_development_dependency 'pry', '~> 0.10'
+  gem.add_development_dependency 'rspec', '~> 3.1', '< 3.2'
+  gem.add_development_dependency 'rspec-collection_matchers', '~> 1.1'
 end