wongi-engine 0.3.8 → 0.4.0.pre.alpha1

data/spec/rule_specs/maybe_rule_spec.rb

@@ -77,6 +77,25 @@ describe "MAYBE rule" do
     }
   end
 
+  it 'should work with with overlays' do
+    prod = engine << maybe_rule
+
+    engine << [1, 2, 3]
+
+    engine << [3, 4, 5]
+    expect(prod.size).to eq(1)
+    expect(prod.tokens.first[:Y]).to be == 5
+
+    engine.with_overlay do |overlay|
+      overlay.retract [3, 4, 5]
+      expect(prod.size).to eq(1)
+      expect(prod.tokens.first[:Y]).to be_nil
+    end
+
+    expect(prod.size).to eq(1)
+    expect(prod.tokens.first[:Y]).to be == 5
+  end
+
   it 'should handle retracted parent tokens' do
     prod = engine << maybe_rule
 
@@ -85,6 +104,44 @@ 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.base_overlay.opt_join_results_for(wme: engine.find(3, 4, 5))).to be_empty
+  end
+
+  context 'should handle retracted parent tokens with overlays' do
+    specify 'variation 1' do
+      prod = engine << maybe_rule
+
+      engine << [1, 2, 3]
+      engine << [3, 4, 5]
+
+      engine.with_overlay do |overlay|
+        engine.retract [1, 2, 3]
+
+        expect(prod).to have(0).tokens
+        expect(overlay.opt_join_results_for(wme: engine.find(3, 4, 5))).to be_empty
+      end
+
+      expect(prod).to have(1).tokens
+      expect(engine.base_overlay.opt_join_results_for(wme: engine.find(3, 4, 5))).not_to be_empty
+    end
+
+    specify 'variation 2' do
+      prod = engine << maybe_rule
+
+      engine << [1, 2, 3]
+      engine << [3, 4, 5]
+
+      engine.with_overlay do |overlay|
+        engine.retract [1, 2, 3]
+        engine << [3, 4, 5]
+        engine.retract [1, 2, 3]
+
+        expect(prod).to have(0).tokens
+        expect(overlay.opt_join_results_for(wme: engine.find(3, 4, 5))).to be_empty
+      end
+
+      expect(prod).to have(1).tokens
+      expect(engine.base_overlay.opt_join_results_for(wme: engine.find(3, 4, 5))).not_to be_empty
+    end
   end
 end

data/spec/rule_specs/ncc_spec.rb

@@ -87,7 +87,6 @@ describe Wongi::Engine::NccNode do
         has :light_kitchen, :value, :on
       }
       make {
-        # trace values: true, generation: true
         gen rule.name, :light_bathroom, :on
         gen rule.name, :want_action_for, :light_bathroom
       }
@@ -106,7 +105,6 @@ describe Wongi::Engine::NccNode do
         }
       }
       make {
-        # trace values: true, generation: true
         gen :Actor, :value, :Value
         gen :Actor, :last_user, :Requestor
       }
@@ -119,22 +117,22 @@ describe Wongi::Engine::NccNode do
 
     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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :off)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).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, :on)]
-    expect(engine.select(:light_bathroom, :last_user, :_)).to be == [Wongi::Engine::WME.new(:light_bathroom, :last_user, :rule1)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :on)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :last_user, :rule1)]
 
     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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :super_on)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :let_there_be_light)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :last_user, :god)]
   end
 
   it 'should clean up correctly with a different activation order' do
@@ -168,29 +166,29 @@ describe Wongi::Engine::NccNode do
       }
     end
 
-    engine << [:user, :priority, 2]
     engine << [:rule1, :priority, 1]
+    engine << [:user, :priority, 2]
     engine << [:poweruser, :priority, 3]
     engine << [:god, :priority, 4]
 
     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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :off)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :off)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :last_user, :user)]
 
     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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :super_on)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).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)]
+    expect(engine.select(:light_bathroom, :value, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :value, :let_there_be_light)]
+    expect(engine.select(:light_bathroom, :last_user, :_).to_a).to be == [Wongi::Engine::WME.new(:light_bathroom, :last_user, :god)]
   end
 
   it 'should ncc-deactivate without destroying tokens' do
@@ -219,6 +217,7 @@ 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]
 
     engine << ["CourseA", "math", 50]
@@ -254,4 +253,64 @@ describe Wongi::Engine::NccNode do
 
     expect(prod).to have(1).tokens
   end
+
+  context "with overlays" do
+    context 'should pass with a mismatching subchain' do
+      specify "variation 1" do
+        engine << ncc_rule
+        production = engine.productions['ncc']
+
+        engine.with_overlay do |overlay|
+          overlay << ["base", "is", 1]
+          expect(production).to have(1).token
+
+          overlay << [1, 2, 3]
+          expect(production).to have(1).token
+
+          overlay << [3, 4, 5]
+          expect(production).to have(0).token
+        end
+
+        expect(production).to have(0).tokens
+      end
+
+      specify "variation 2" do
+        engine << ncc_rule
+        overlay = engine.base_overlay
+        production = engine.productions['ncc']
+
+        overlay << ["base", "is", 1]
+        expect(production).to have(1).token
+
+        engine.with_overlay do |overlay|
+          overlay << [1, 2, 3]
+          expect(production).to have(1).token
+
+          overlay << [3, 4, 5]
+          expect(production).to have(0).token
+        end
+
+        expect(production).to have(1).tokens
+      end
+
+      specify "variation 3" do
+        engine << ncc_rule
+        overlay = engine.base_overlay
+        production = engine.productions['ncc']
+
+        overlay << ["base", "is", 1]
+        expect(production).to have(1).token
+
+        overlay << [1, 2, 3]
+        expect(production).to have(1).token
+
+        engine.with_overlay do |overlay|
+          overlay << [3, 4, 5]
+          expect(production).to have(0).token
+        end
+
+        expect(production).to have(1).tokens
+      end
+    end
+  end
 end

data/spec/rule_specs/negative_rule_spec.rb

@@ -4,6 +4,22 @@ describe "negative rule" do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 
+  it "works" do
+    prod = engine << rule {
+      forall {
+        neg :x, :y, :z
+      }
+    }
+
+    expect(prod).to have(1).tokens
+
+    engine << [:x, :y, 42]
+    expect(prod).to have(1).tokens
+
+    engine << %i[x y z]
+    expect(prod).to have(0).tokens
+  end
+
   it "should not introduce variables" do
     proc = lambda {
       engine << rule('one-option') {
@@ -52,20 +68,18 @@ describe "negative rule" do
     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
+  it "should not create infinite feedback loops by default" do
+    engine << rule('feedback') {
+      forall {
+        neg :a, :b, :_
+      }
+      make {
+        gen :a, :b, :c
+      }
+    }
 
-  # end
+    engine.should have(1).facts
+  end
 
   it "should create infinite feedback loops with unsafe option" do
     counter = 0

data/spec/spec_helper.rb

@@ -1,3 +1,7 @@
 require 'pry'
 require 'wongi-engine'
 require 'rspec/collection_matchers'
+
+def print_dot_graph(engine, io: $stderr)
+  Wongi::Engine::Graph.new(engine).dot(io)
+end

data/spec/wme_spec.rb

@@ -19,40 +19,8 @@ describe Wongi::Engine::WME do
       expect(subject.predicate).to be == "b"
       expect(subject.object).to be == "c"
     end
-
-    # it 'should use the rete to import members' do
-
-    #   rete = capitalizing_rete
-
-    #   wme = Wongi::Engine::WME.new "a", "b", "c", rete
-
-    #   expect( wme.subject ).to be == "A"
-    #   expect( wme.predicate ).to be == "B"
-    #   expect( wme.object ).to be == "C"
-
-    # end
-
-    it {
-      should be_manual
-    }
-
-    it {
-      should_not be_generated
-    }
   end
 
-  # it 'should be able to import into rete' do
-
-  #   rete = capitalizing_rete
-
-  #   imported = subject.import_into rete
-
-  #   expect( imported.subject ).to be == "A"
-  #   expect( imported.predicate ).to be == "B"
-  #   expect( imported.object ).to be == "C"
-
-  # end
-
   it 'should compare instances' do
     wme1 = Wongi::Engine::WME.new "a", "b", "c"
     wme2 = Wongi::Engine::WME.new "a", "b", "c"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0.pre.alpha1
 platform: ruby
 authors:
 - Valeri Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-06 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -91,11 +91,11 @@ files:
 - examples/rdf.rb
 - examples/timeline.rb
 - lib/wongi-engine.rb
+- lib/wongi-engine/alpha_index.rb
 - lib/wongi-engine/alpha_memory.rb
 - lib/wongi-engine/beta.rb
 - lib/wongi-engine/beta/aggregate_node.rb
 - lib/wongi-engine/beta/assignment_node.rb
-- lib/wongi-engine/beta/beta_memory.rb
 - lib/wongi-engine/beta/beta_node.rb
 - lib/wongi-engine/beta/filter_node.rb
 - lib/wongi-engine/beta/join_node.rb
@@ -105,12 +105,12 @@ files:
 - lib/wongi-engine/beta/optional_node.rb
 - lib/wongi-engine/beta/or_node.rb
 - lib/wongi-engine/beta/production_node.rb
+- lib/wongi-engine/beta/root_node.rb
 - lib/wongi-engine/compiler.rb
 - lib/wongi-engine/core_ext.rb
-- lib/wongi-engine/data_overlay.rb
 - lib/wongi-engine/dsl.rb
 - lib/wongi-engine/dsl/action/assign_action.rb
-- lib/wongi-engine/dsl/action/base.rb
+- lib/wongi-engine/dsl/action/base_action.rb
 - lib/wongi-engine/dsl/action/error_generator.rb
 - lib/wongi-engine/dsl/action/simple_action.rb
 - lib/wongi-engine/dsl/action/simple_collector.rb
@@ -143,13 +143,16 @@ files:
 - lib/wongi-engine/network.rb
 - lib/wongi-engine/network/collectable.rb
 - lib/wongi-engine/network/debug.rb
+- lib/wongi-engine/overlay.rb
 - lib/wongi-engine/ruleset.rb
 - lib/wongi-engine/template.rb
 - lib/wongi-engine/token.rb
+- lib/wongi-engine/token_assignment.rb
 - lib/wongi-engine/version.rb
 - lib/wongi-engine/wme.rb
 - lib/wongi-engine/wme_match_data.rb
 - spec/action_class_spec.rb
+- spec/alpha_index_spec.rb
 - spec/beta_node_spec.rb
 - spec/bug_specs/issue_4_spec.rb
 - spec/dataset_spec.rb
@@ -168,7 +171,6 @@ files:
 - spec/rule_specs/maybe_rule_spec.rb
 - spec/rule_specs/ncc_spec.rb
 - spec/rule_specs/negative_rule_spec.rb
-- spec/rule_specs/or_rule_spec.rb
 - spec/ruleset_spec.rb
 - spec/simple_action_spec.rb
 - spec/spec_helper.rb
@@ -190,11 +192,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: A forward-chaining rule engine in pure Ruby.

data/lib/wongi-engine/beta/beta_memory.rb

@@ -1,60 +0,0 @@
-module Wongi::Engine
-  class BetaMemory < BetaNode
-    include TokenContainer
-
-    def seed(assignments = {})
-      @seed = assignments
-      t = Token.new(self, nil, nil, assignments)
-      rete.default_overlay.add_token(t, self)
-    end
-
-    def subst(valuations)
-      beta_deactivate(tokens.first)
-      token = Token.new(self, nil, nil, @seed)
-      valuations.each { |variable, value| token.subst variable, value }
-      beta_activate(token)
-    end
-
-    def beta_activate(token)
-      existing = tokens.find { |et| et.duplicate? token }
-      return if existing # TODO: really?
-
-      token.overlay.add_token(token, self)
-      children.each do |child|
-        child.beta_activate token
-      end
-      token
-    end
-
-    def beta_deactivate(token)
-      return nil unless tokens.find token
-
-      token.overlay.remove_token(token, self)
-      token.deleted!
-      if token.parent
-        token.parent.children.delete token # should this go into Token#destroy?
-      end
-      children.each do |child|
-        child.beta_deactivate token
-      end
-      token
-    end
-
-    def refresh_child(child)
-      tokens.each do |token|
-        child.beta_activate token
-      end
-    end
-  end
-
-  # SingletonBetaMemory is a memory node that only holds one token at a time.
-  # It should only be used after aggregate nodes.
-  class SingletonBetaMemory < BetaMemory
-    def beta_activate(token)
-      if (t = tokens.first)
-        beta_deactivate(t)
-      end
-      super
-    end
-  end
-end

data/lib/wongi-engine/data_overlay.rb

@@ -1,141 +0,0 @@
-module Wongi::Engine
-  class DataOverlay
-    attr_reader :rete, :parent
-
-    def initialize(rete, parent = nil)
-      @rete = rete
-      @parent = parent
-      @raw_wmes = Hash.new { |h, k| h[k] = [] }
-      @raw_tokens = Hash.new { |h, k| h[k] = [] }
-      rete.add_overlay(self)
-    end
-
-    def new_child
-      DataOverlay.new(rete, self)
-    end
-
-    def with_child
-      return unless block_given?
-
-      new_child.tap do |overlay|
-        yield overlay
-      ensure
-        overlay.dispose
-      end
-    end
-
-    def ancestor?(other)
-      return false if parent.nil?
-      return true if parent == other
-
-      parent.ancestor?(other)
-    end
-
-    def dispose
-      return if self == rete.default_overlay
-
-      rete.remove_overlay(self)
-      @raw_tokens.each_value do |tokens|
-        tokens.each(&:dispose!)
-      end
-      @raw_tokens.clear
-    end
-
-    def <<(thing)
-      case thing
-      when Array
-        assert(WME.new(*thing).tap { |wme| wme.overlay = self })
-      when WME
-        assert(thing)
-      else
-        raise Error, "overlays can only accept data"
-      end
-    end
-
-    def assert(wme)
-      @next_cascade ||= []
-      @next_cascade << [:assert, wme]
-      return if @current_cascade
-
-      @current_cascade = @next_cascade
-      @next_cascade = nil
-      process_cascade
-    end
-
-    def retract(wme, options = {})
-      wme = WME.new(*wme) if wme.is_a? Array
-      @next_cascade ||= []
-      @next_cascade << [:retract, wme, options]
-      return if @current_cascade
-
-      @current_cascade = @next_cascade
-      @next_cascade = nil
-      process_cascade
-    end
-
-    def process_cascade
-      while @current_cascade
-        @current_cascade.each do |(operation, wme, options)|
-          case operation
-          when :assert
-            wme.overlay = self
-            rete.real_assert(wme)
-          when :retract
-            rete.real_retract(wme, options)
-            wme.overlay = nil
-          end
-        end
-        @current_cascade = @next_cascade
-        @next_cascade = nil
-      end
-    end
-
-    def highest(other)
-      return self if self == other
-      return self if other.nil?
-      return self if ancestor?(other)
-      return other if other.ancestor?(self)
-
-      nil # unrelated lineages
-    end
-
-    # TODO: this is inconsistent.
-    # A WME retracted in-flight will be visible in active enumerators
-    # but a token will not.
-    # But this is how it works.
-
-    def wmes(alpha)
-      DuplicatingEnumerator.new(raw_wmes(alpha))
-    end
-
-    def tokens(beta)
-      DeleteSafeEnumerator.new(raw_tokens(beta))
-    end
-
-    def add_wme(wme, alpha)
-      wmes = raw_wmes(alpha)
-      wmes << wme unless wmes.include?(wme)
-    end
-
-    def remove_wme(wme, alpha)
-      raw_wmes(alpha).delete(wme)
-    end
-
-    def add_token(token, beta)
-      tokens = raw_tokens(beta)
-      tokens << token unless tokens.include?(token)
-    end
-
-    def remove_token(token, beta)
-      raw_tokens(beta).delete(token)
-    end
-
-    def raw_wmes(alpha)
-      @raw_wmes[alpha.object_id]
-    end
-
-    def raw_tokens(beta)
-      @raw_tokens[beta.object_id]
-    end
-  end
-end

data/spec/rule_specs/or_rule_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe "ANY rule" do
-  include Wongi::Engine::DSL
-
-  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
-    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' do
-      engine << [:x, :path1, true]
-      engine << [:x, :path2, true]
-      expect(production.tokens).to have(2).items
-    end
-  end
-end