wongi-engine 0.0.16 → 0.0.17

data/spec/beta_node_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Wongi::Engine::BetaNode do
+
+  let( :engine ) { Wongi::Engine.create }
+
+  describe '#tokens' do
+
+    it 'should be enumerable' do
+
+      production = engine << rule {
+        forall {
+          has :x, :y, :Z
+        }
+      }
+
+      engine << [:x, :y, 1]
+      engine << [:x, :y, 2]
+      engine << [:x, :y, 3]
+      zs = production.tokens.map { |token| token[:Z] }
+      expect( zs ).to be == [1, 2, 3]
+
+    end
+
+  end
+
+end

data/spec/dataset_spec.rb

@@ -20,6 +20,7 @@ describe Wongi::Engine::Network do
     ds << [1, 2, 3]
 
     expect(production.size).to eq(1)
+    expect( production.size ).to be == 1
 
   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/ncc_spec.rb

@@ -22,6 +22,19 @@ describe "NCC rule" do
     }
   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
@@ -60,6 +73,26 @@ describe "NCC rule" do
 
   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

data/spec/rule_specs/negative_rule_spec.rb

@@ -1,70 +1,105 @@
-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
+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
+
+  specify "variable example 1" do
+
+    prod = engine << rule {
+      forall {
+        has :x, :y, :Z
+        neg :a, :b, :Z
+      }
+    }
+
+    engine << [:x, :y, 1]
+    expect( prod ).to have(1).tokens
+
+    engine << [:a, :b, 1]
+    expect( prod ).to have(0).tokens
+
+  end
+
+  specify "variable example 1" do
+
+    prod = engine << rule {
+      forall {
+        has :x, :y, :Z
+        neg :a, :b, :Z
+      }
+    }
+
+    engine << [:a, :b, 1]
+    engine << [:x, :y, 1]
+    expect( prod ).to have(0).tokens
+
+    engine.retract [:a, :b, 1]
+    expect( prod ).to have(1).tokens
+
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Valeri Sokolov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -115,6 +115,7 @@ files:
 - lib/wongi-engine/dsl/actions/statement_generator.rb
 - lib/wongi-engine/dsl/actions/trace_action.rb
 - lib/wongi-engine/dsl/any_rule.rb
+- lib/wongi-engine/dsl/assuming.rb
 - lib/wongi-engine/dsl/dsl_builder.rb
 - lib/wongi-engine/dsl/dsl_extensions.rb
 - lib/wongi-engine/dsl/extension_clause.rb
@@ -142,6 +143,7 @@ files:
 - lib/wongi-engine/version.rb
 - lib/wongi-engine/wme.rb
 - lib/wongi-engine/wme_match_data.rb
+- spec/beta_node_spec.rb
 - spec/bug_specs/issue_4_spec.rb
 - spec/dataset_spec.rb
 - spec/dsl_spec.rb
@@ -150,6 +152,7 @@ files:
 - spec/high_level_spec.rb
 - spec/rule_specs/any_rule_spec.rb
 - spec/rule_specs/assign_spec.rb
+- spec/rule_specs/assuming_spec.rb
 - spec/rule_specs/maybe_rule_spec.rb
 - spec/rule_specs/ncc_spec.rb
 - spec/rule_specs/negative_rule_spec.rb
@@ -183,6 +186,7 @@ signing_key:
 specification_version: 4
 summary: A forward-chaining rule engine in pure Ruby.
 test_files:
+- spec/beta_node_spec.rb
 - spec/bug_specs/issue_4_spec.rb
 - spec/dataset_spec.rb
 - spec/dsl_spec.rb
@@ -191,6 +195,7 @@ test_files:
 - spec/high_level_spec.rb
 - spec/rule_specs/any_rule_spec.rb
 - spec/rule_specs/assign_spec.rb
+- spec/rule_specs/assuming_spec.rb
 - spec/rule_specs/maybe_rule_spec.rb
 - spec/rule_specs/ncc_spec.rb
 - spec/rule_specs/negative_rule_spec.rb