wongi-engine 0.3.9 → 0.4.0.pre.alpha1

data/lib/wongi-engine/version.rb

@@ -1,5 +1,5 @@
 module Wongi
   module Engine
-    VERSION = "0.3.9".freeze
+    VERSION = "0.4.0-alpha1".freeze
   end
 end

data/lib/wongi-engine/wme.rb

@@ -1,49 +1,20 @@
 module Wongi::Engine
   WME = Struct.new(:subject, :predicate, :object) do
-    include CoreExt
+    def self.from_concrete_template(template)
+      raise "template #{template} is not concrete" unless template.concrete?
 
-    attr_reader :rete
-
-    attr_reader :generating_tokens
-    attr_reader :neg_join_results, :opt_join_results
-    attr_accessor :overlay
-
-    attr_predicate :deleted
-    attr_predicate :manual
-
-    def initialize(s, p, o, r = nil)
-      manual!
-
-      @deleted = false
-      @alphas = []
-      @generating_tokens = []
-      @neg_join_results = []
-      @opt_join_results = []
-
-      @rete = r
-
-      # TODO: reintroduce Network#import when bringing back RDF support
-      super(s, p, o)
-    end
-
-    def import_into(r)
-      self.class.new(subject, predicate, object, r).tap do |wme|
-        wme.overlay = overlay
-        wme.manual = manual?
-      end
+      new(template.subject, template.predicate, template.object)
     end
 
     def dup
-      self.class.new(subject, predicate, object, rete).tap do |wme|
-        wme.overlay = overlay
-        wme.manual = manual?
-      end
+      self.class.new(subject, predicate, object)
     end
 
     def ==(other)
-      subject == other.subject && predicate == other.predicate && object == other.object
+      other && subject == other.subject && predicate == other.predicate && object == other.object
     end
 
+    # @param template Wongi::Engine::Template
     def =~(template)
       raise Wongi::Engine::Error, "Cannot match a WME against a #{template.class}" unless template.is_a?(Template)
 
@@ -51,10 +22,6 @@ module Wongi::Engine
       result if result.match?
     end
 
-    def generated?
-      !generating_tokens.empty?
-    end
-
     def inspect
       "{#{subject.inspect} #{predicate.inspect} #{object.inspect}}"
     end
@@ -67,6 +34,10 @@ module Wongi::Engine
       @hash ||= [subject.hash, predicate.hash, object.hash].hash
     end
 
+    def eql?(other)
+      subject.eql?(other.subject) && predicate.eql?(other.predicate) && object.eql?(other.object)
+    end
+
     protected
 
     def match_member(mine, theirs)

data/lib/wongi-engine.rb

@@ -21,12 +21,14 @@ require 'wongi-engine/wme'
 require 'wongi-engine/wme_match_data'
 require 'wongi-engine/token'
 require 'wongi-engine/filter'
+require 'wongi-engine/alpha_index'
 require 'wongi-engine/alpha_memory'
+require 'wongi-engine/token_assignment'
 require 'wongi-engine/beta'
 require 'wongi-engine/dsl'
 require 'wongi-engine/ruleset'
 require 'wongi-engine/compiler'
-require 'wongi-engine/data_overlay'
+require 'wongi-engine/overlay'
 require 'wongi-engine/enumerators'
 require 'wongi-engine/network'
 require 'wongi-engine/graph'

data/spec/alpha_index_spec.rb

@@ -0,0 +1,78 @@
+require 'rspec'
+require 'spec_helper'
+
+describe Wongi::Engine::AlphaIndex do
+  let(:index) { described_class.new(pattern) }
+  let(:wme) { Wongi::Engine::WME.new(1, 2, 3) }
+
+  # private access
+  let(:collection) { index.send(:index) }
+
+  before do
+    index.add(wme)
+  end
+
+  context 'index by subject' do
+    let(:pattern) { %i[subject] }
+    let(:key) { hashed_key([1]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  context 'index by predicate' do
+    let(:pattern) { %i[predicate] }
+    let(:key) { hashed_key([2]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  context 'index by object' do
+    let(:pattern) { %i[object] }
+    let(:key) { hashed_key([3]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  context 'index by subject and predicate' do
+    let(:pattern) { %i[subject predicate] }
+    let(:key) { hashed_key([1, 2]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  context 'index by subject and object' do
+    let(:pattern) { %i[subject object] }
+    let(:key) { hashed_key([1, 3]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  context 'index by predicate and object' do
+    let(:pattern) { %i[predicate object] }
+    let(:key) { hashed_key([2, 3]) }
+
+    it 'indexes by pattern' do
+      expect(collection.keys).to eq([key])
+      expect(collection[key]).to eq([wme])
+    end
+  end
+
+  def hashed_key(key)
+    key.map(&:hash)
+  end
+end

data/spec/bug_specs/issue_4_spec.rb

@@ -22,8 +22,8 @@ describe "issue 4" do
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers).to be_empty
-    expect(evens.length).to eq(10)
+    expect(numbers.size).to eq(0)
+    expect(evens.size).to eq(10)
   end
 
   it "should correctly retract post-added items from within a rule" do
@@ -42,13 +42,13 @@ describe "issue 4" do
       }
     end
 
-    10.times { |i| engine << [i, :is_number, true] }
+    5.times { |i| engine << [i, :is_number, true] }
 
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers).to be_empty
-    expect(evens.length).to eq(10)
+    expect(numbers.size).to eq(0)
+    expect(evens.size).to eq(5)
   end
 
   # cascaded processing affects this
@@ -80,9 +80,9 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers).to be_empty
-    expect(evens).to have(5).items
-    expect(odds).to have(5).items
+    expect(numbers.size).to eq(0)
+    expect(evens.size).to eq(5)
+    expect(odds.size).to eq(5)
   end
 
   it "should not lose track when another rule affects a set" do
@@ -126,8 +126,8 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers.length).to eq(5)
-    expect(evens.length).to eq(5)
-    expect(odds.length).to eq(5)
+    expect(numbers.size).to eq(5)
+    expect(evens.size).to eq(5)
+    expect(odds.size).to eq(5)
   end
 end

data/spec/high_level_spec.rb

@@ -30,9 +30,9 @@ describe 'the engine' do
       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")
+      expect(engine.facts.select { engine.current_overlay.manual?(_1) }.length).to eq(2)
+      generated = engine.facts.select { engine.current_overlay.generated?(_1) }
+      expect(generated).to eq([Wongi::Engine::WME.new("Bob", "friend", "Alice")])
     end
 
     it 'should generate wmes with an added rule' do
@@ -51,8 +51,8 @@ describe 'the engine' do
         }
       }
 
-      expect(engine.facts.to_a.length).to eq(3)
-      expect(engine.facts.select(&:manual?).size).to eq(2)
+      expect(engine.facts.to_a.size).to eq(3)
+      expect(engine.facts.select { engine.current_overlay.manual?(_1) }.size).to eq(2)
     end
 
     it 'should not get confused by recursive activations' do
@@ -70,9 +70,9 @@ describe 'the engine' do
       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)
+      expect(engine.wmes.count).to eq(4)
+      expect(engine.select(:x, :p, :x).count).to eq(1)
+      expect(engine.select(:y, :p, :y).count).to eq(1)
     end
   end
 
@@ -236,97 +236,4 @@ describe 'the engine' do
       expect(engine.results["test-query"].size).to eq(1)
     end
   end
-
-  context 'with timelines' do
-    it 'should not match with no past point' do
-      production = engine.rule {
-        forall {
-          has 1, 2, 3, time: -1
-        }
-      }
-
-      expect(production.size).to eq(0)
-
-      engine << [1, 2, 3]
-
-      expect(production.size).to eq(0)
-    end
-
-    it 'should match a simple past point' do
-      production = engine.rule {
-        forall {
-          has 1, 2, 3, time: -1
-        }
-      }
-
-      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 = engine.rule do
-          forall {
-            asserted 1, 2, 3
-          }
-          make { action { count += 1 } }
-        end
-        expect(production.size).to eq(0)
-        engine.snapshot!
-        engine << [1, 2, 3]
-        expect(production.size).to eq(1)
-        # puts count
-      end
-
-      it 'should not match kept items' do
-        count = 0
-        production = engine.rule do
-          forall {
-            asserted 1, 2, 3
-          }
-          make { action { count += 1 } }
-        end
-        engine << [1, 2, 3]
-        expect(production.size).to eq(1)
-        engine.snapshot!
-        expect(production.size).to eq(0)
-        # puts count
-      end
-    end
-
-    context 'using the :kept clause' do
-      it 'should match kept items' do
-        count = 0
-        production = engine.rule do
-          forall {
-            kept 1, 2, 3
-          }
-          make { action { count += 1 } }
-        end
-        engine << [1, 2, 3]
-        expect(production.size).to eq(0)
-        engine.snapshot!
-        expect(production.size).to eq(1)
-        # puts count
-      end
-
-      it 'should not match asserted wmes' do
-        count = 0
-        production = engine.rule do
-          forall {
-            kept 1, 2, 3
-          }
-          make { action { count += 1 } }
-        end
-        expect(production.size).to eq(0)
-        engine.snapshot!
-        engine << [1, 2, 3]
-        expect(production.size).to eq(0)
-        # puts count
-      end
-    end
-  end
 end

data/spec/network_spec.rb

@@ -14,7 +14,7 @@ describe Wongi::Engine::Network do
   it 'should retract facts' do
     subject << [1, 2, 3]
     subject.retract [1, 2, 3]
-    expect(subject.select(:_, 2, :_)).to be_empty
+    expect(subject.select(:_, 2, :_).count).to eq(0)
   end
 
   it 'asserted facts end up in productions' do
@@ -80,7 +80,7 @@ describe Wongi::Engine::Network do
   end
 
   it 'retracted facts should propagate through join chains' do
-    deactivated = nil
+    assignments = nil
 
     prod = engine << rule {
       forall {
@@ -88,7 +88,9 @@ describe Wongi::Engine::Network do
         has :Y, :is, :Z
       }
       make {
-        action deactivate: ->(token) { deactivated = token }
+        action deactivate: lambda { |token|
+          assignments = token.assignments
+        }
       }
     }
 
@@ -99,9 +101,9 @@ describe Wongi::Engine::Network do
 
     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(assignments[:X].call).to be == 1
+    expect(assignments[:Y].call).to be == 2
+    expect(assignments[:Z].call).to be == 3
   end
 
   it 'retraction should reactivate neg nodes' do

data/spec/overlay_spec.rb

@@ -1,16 +1,157 @@
 require 'spec_helper'
+require 'wongi-engine/alpha_index'
+require 'wongi-engine/overlay'
+require 'wongi-engine/wme'
 
-describe Wongi::Engine::DataOverlay do
+describe Wongi::Engine::Overlay do
   include Wongi::Engine::DSL
 
   let(:engine) { Wongi::Engine.create }
 
+  describe "asserting facts" do
+    let(:engine) { double(:engine) }
+    let(:overlay) { Wongi::Engine::Overlay.new(engine) }
+
+    before do
+      # this cannot be put in the double constructor because it causes an infinite recursion
+      allow(engine).to receive(:default_overlay).and_return(overlay)
+      allow(engine).to receive(:real_assert)
+    end
+
+    it 'stores WMEs and retrieves by identity' do
+      wmes = [
+        Wongi::Engine::WME.new(1, 11, 111),
+        Wongi::Engine::WME.new(1, 11, 112),
+        Wongi::Engine::WME.new(1, 11, 113),
+        Wongi::Engine::WME.new(1, 12, 121),
+        Wongi::Engine::WME.new(1, 12, 122),
+        Wongi::Engine::WME.new(2, 22, 222),
+        Wongi::Engine::WME.new(2, 22, 223),
+        Wongi::Engine::WME.new(3, 33, 333),
+        Wongi::Engine::WME.new(3, 34, 333),
+      ]
+      wmes.each { overlay.assert(_1) }
+
+      wmes.each { expect(overlay.find(_1)).to equal(_1) }
+    end
+
+    it 'stores WMEs and retrieves by template' do
+      wmes = [
+        Wongi::Engine::WME.new(1, 11, 111),
+        Wongi::Engine::WME.new(1, 11, 112),
+        Wongi::Engine::WME.new(1, 11, 113),
+        Wongi::Engine::WME.new(1, 12, 121),
+        Wongi::Engine::WME.new(1, 12, 122),
+        Wongi::Engine::WME.new(2, 11, 111),
+        Wongi::Engine::WME.new(2, 11, 222),
+        Wongi::Engine::WME.new(2, 22, 222),
+        Wongi::Engine::WME.new(2, 22, 223),
+        Wongi::Engine::WME.new(3, 33, 113),
+        Wongi::Engine::WME.new(3, 33, 333),
+        Wongi::Engine::WME.new(3, 34, 333),
+      ]
+      wmes.each { overlay.assert(_1) }
+
+      expect(overlay.select(1, :_, :_)).to have(5).items
+      expect(overlay.select(2, :_, :_)).to have(4).items
+      expect(overlay.select(3, :_, :_)).to have(3).items
+      expect(overlay.select(1, 11, :_)).to have(3).items
+      expect(overlay.select(:_, 11, :_)).to have(5).items
+      expect(overlay.select(:_, :_, 113)).to have(2).items
+      expect(overlay.select(:_, 22, :_)).to have(2).items
+      expect(overlay.select(:_, 22, 222)).to have(1).items
+      expect(overlay.select(:_, :_, 222)).to have(2).items
+      expect(overlay.select(:_, :_, 223)).to have(1).items
+
+      expect(overlay.select(:_, :_, :_)).to have(wmes.length).items
+
+      expect(overlay.select(1, 11, 111)).to have(1).items
+      expect(overlay.select(1, 11, 111).first).to equal(wmes.first)
+    end
+  end
+
+  context "retracting facts" do
+    let(:engine) { double(:engine) }
+    let(:overlay) { Wongi::Engine::Overlay.new(engine) }
+
+    before do
+      # this cannot be put in the double constructor because it causes an infinite recursion
+      allow(engine).to receive(:default_overlay).and_return(overlay)
+      allow(engine).to receive(:real_assert)
+      allow(engine).to receive(:real_retract)
+    end
+
+    it "removes asserted facts" do
+      wme = Wongi::Engine::WME.new(1, 11, 111)
+
+      overlay.assert(wme)
+      expect(overlay.select(:_, :_, :_)).to have(1).items
+
+      overlay.retract(wme)
+      expect(overlay.select(:_, :_, :_)).to have(0).items
+    end
+  end
+
+  context "layered" do
+    let(:engine) { double(:engine) }
+    let(:overlay) { Wongi::Engine::Overlay.new(engine) }
+
+    before do
+      # this cannot be put in the double constructor because it causes an infinite recursion
+      allow(engine).to receive(:default_overlay).and_return(overlay)
+      allow(engine).to receive(:real_assert)
+      allow(engine).to receive(:real_retract)
+    end
+    it "maintains visibility on each layer" do
+      child1 = overlay.new_child
+      child2 = child1.new_child
+
+      wme = Wongi::Engine::WME.new(1, 2, 3)
+
+      overlay.assert(wme)
+      expect(overlay.find(wme)).to eq(wme)
+      expect(child1.find(wme)).to eq(wme)
+      expect(child2.find(wme)).to eq(wme)
+
+      child1.retract(wme)
+      expect(overlay.find(wme)).to eq(wme)
+      expect(child1.find(wme)).to be_nil
+      expect(child2.find(wme)).to be_nil
+
+      child2.assert(wme)
+      expect(overlay.find(wme)).to eq(wme)
+      expect(child1.find(wme)).to be_nil
+      expect(child2.find(wme)).to eq(wme)
+
+      child2.retract(wme)
+      expect(overlay.find(wme)).to eq(wme)
+      expect(child1.find(wme)).to be_nil
+      expect(child2.find(wme)).to be_nil
+
+      child1.assert(wme)
+      expect(overlay.find(wme)).to eq(wme)
+      expect(child1.find(wme)).to eq(wme)
+      expect(child2.find(wme)).to eq(wme)
+
+      overlay.retract(wme)
+      expect(overlay.find(wme)).to be_nil
+      expect(child1.find(wme)).to be_nil
+      expect(child2.find(wme)).to be_nil
+
+      child1.assert(wme)
+      expect(overlay.find(wme)).to be_nil
+      expect(child1.find(wme)).to eq(wme)
+      expect(child2.find(wme)).to eq(wme)
+    end
+  end
+
   it 'should be disposable' do
     production = engine << rule {
       forall {
         has 1, 2, :X
       }
     }
+
     engine.with_overlay { |overlay|
       overlay << [1, 2, 3]
       expect(production).to have(1).token
@@ -18,6 +159,24 @@ describe Wongi::Engine::DataOverlay do
     expect(production).to have(0).tokens
   end
 
+  it 'works with retractions' do
+    production = engine << rule {
+      forall {
+        has 1, 2, :X
+      }
+    }
+
+    engine << [1, 2, 3]
+    expect(production).to have(1).token
+
+    engine.with_overlay do |overlay|
+      overlay.retract [1, 2, 3]
+      expect(production).to have(0).token
+    end
+
+    expect(production).to have(1).token
+  end
+
   it 'should generate into correct overlays' do
     production = engine << rule {
       forall {
@@ -46,12 +205,11 @@ describe Wongi::Engine::DataOverlay do
     expect(prod).to have(1).tokens
 
     engine.with_overlay do |overlay|
-      overlay << [:x, :y, :z]
+      overlay << %i[x y z]
       expect(prod).to have(0).tokens
     end
 
     expect(prod).to have(1).tokens
-
   end
 
   it 'works with assignments' do

data/spec/rule_specs/any_rule_spec.rb

@@ -27,6 +27,45 @@ describe "ANY rule" do
     end
   end
 
+  context 'with two options' do
+    let :production do
+      engine << rule do
+        forall {
+          any {
+            option {
+              has :A, :path1, :_
+            }
+            option {
+              has :A, :path2, :_
+            }
+          }
+        }
+      end
+    end
+
+    it 'should fire on the first path' do
+      engine << [:x, :path1, true]
+      expect(production.tokens).to have(1).item
+    end
+
+    it 'should fire on the second path' do
+      engine << [:x, :path2, true]
+      expect(production.tokens).to have(1).item
+    end
+
+    it 'should fire twice on both paths at once and be retractable' do
+      engine << [:x, :path1, true]
+      engine << [:x, :path2, true]
+      expect(production.tokens).to have(2).items
+
+      engine.retract [:x, :path2, true]
+      expect(production.tokens).to have(1).items
+
+      engine.retract [:x, :path1, true]
+      expect(production.tokens).to have(0).items
+    end
+  end
+
   context "with several options" do
     specify "all matching branches must pass" do
       engine << rule('two-options') {

data/spec/rule_specs/assign_spec.rb

@@ -80,7 +80,7 @@ describe "ASSIGN rule" do
     expect(x).to be == 1
   end
 
-  xit 'should handle booleans' do
+  it 'should handle booleans' do
     engine << rule do
       forall {
         has :a, :b, :c