wongi-engine 0.4.0.pre.alpha2 → 0.4.0.pre.alpha4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49eb7efc3f4049b38a7035208884d2078e0e31e68d396fb647deb81add7a030c
-  data.tar.gz: 6916568d628dbfce536001472c224f0fcee9ab580d4d9f2df30f04edb77bb45d
+  metadata.gz: 566bc82ac763603c9e6a5556677364af9e57449bcb839c00865c3dd8cefbc1dc
+  data.tar.gz: d8285247fbe76bcf603740f7e6a6dd603226ea5c1e47564223b851c087a148e6
 SHA512:
-  metadata.gz: 437466d4256f5ff96bf741e879054f2e5a7499f3876ed73cbd00b155caf6b5f06cfb60378941e36cba6dd912b8d61cbe8b4cdfec58a0b60f121841cdd63c3bd9
-  data.tar.gz: 5e8ca5469c6b20cb63928a0c4c128f3391ae74c29e09608b0a7045d6d979bc03d9d8b95f49f4282898531ee8f69e7bd9abcd8ebb8164aa4d612292e01b509be3
+  metadata.gz: a88bbad2800cf1701d66277cbffc646fe92e0a283bb6da8f3bc828fbfdea001d3f4040be35a039372d7db4680c7acb763ccfe91e94f233be90b5182697f24602
+  data.tar.gz: b00126ee326301079e7c257548b6ce650682f0d8637056445760a3f0cc25da96411d4be8fc50edea8f343cdf1523f9ab82ec8d719a20a232128e7622f99ae331

data/.rubocop.yml

@@ -42,9 +42,6 @@ Naming/MethodParameterName:
 Layout/LineLength:
   Enabled: false
 
-RSpec:
-  Enabled: false
-
 Style/SafeNavigation:
   Enabled: false
 

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

@@ -1,41 +1,37 @@
 module Wongi::Engine
   class AggregateNode < BetaNode
-    attr_reader :alpha, :tests, :assignment_pattern, :map, :function, :assign
+    attr_reader :var, :over, :partition, :aggregate, :map
 
-    def initialize(parent, alpha, tests, assignment, map, function, assign)
+    def initialize(parent, var, over, partition, aggregate, map)
       super(parent)
-      @alpha = alpha
-      @tests = tests
-      @assignment_pattern = assignment
-      @map = map
-      @function = function
-      @assign = assign
+      @var = var
+      @over = over
+      @partition = make_partition_fn(partition)
+      @aggregate = make_aggregate_fn(aggregate)
+      @map = make_map_fn(map)
     end
 
-    def equivalent?(alpha, tests, assignment_pattern)
-      return false if self.alpha != alpha
-      return false if self.assignment_pattern != assignment_pattern
-      return true if self.tests.empty? && tests.empty?
-      return false if self.tests.length != tests.length
+    def make_partition_fn(partition)
+      return nil if partition.nil?
 
-      self.tests.all? { |my_test|
-        tests.any? { |new_test|
-          my_test.equivalent? new_test
-        }
-      }
+      if Template.variable?(partition)
+        ->(token) { token[partition] }
+      elsif partition.is_a?(Array) && partition.all? { Template.variable?(_1) }
+        ->(token) { token.values_at(*partition) }
+      else
+        partition
+      end
     end
 
-    def alpha_activate(wme)
-      # we need to re-run all WMEs through the aggregator, so the new incoming one doesn't matter
-      tokens.each do |token|
-        evaluate(wme: wme, token: token)
-      end
+    def make_aggregate_fn(agg)
+      agg
     end
 
-    def alpha_deactivate(wme)
-      # we need to re-run all WMEs through the aggregator, so the new incoming one doesn't matter
-      tokens.each do |token|
-        evaluate(wme: wme, token: token)
+    def make_map_fn(map)
+      if map.nil?
+        ->(token) { token[over] }
+      else
+        map
       end
     end
 
@@ -43,42 +39,37 @@ module Wongi::Engine
       return if tokens.find { |t| t.duplicate? token }
 
       overlay.add_token(token)
-      evaluate(wme: nil, token: token)
+      evaluate
     end
 
     def beta_deactivate(token)
       overlay.remove_token(token)
-      beta_deactivate_children(token: token)
+      beta_deactivate_children(token:)
+      evaluate
     end
 
     def refresh_child(child)
-      tokens.each do |token|
-        evaluate(wme: nil, token: token, child: child)
-      end
+      evaluate(child: child)
     end
 
-    def evaluate(wme:, token:, child: nil)
-      # clean up previous decisions
-      # # TODO: optimise: only clean up if the value changed
-      beta_deactivate_children(token: token)
-
-      template = specialize(alpha.template, tests, token)
-      candidates = select_wmes(template) { |asserted_wme| matches?(token, asserted_wme) }
-
-      return if candidates.empty?
-
-      mapped = candidates.map(&map)
-      value = if function.is_a?(Symbol) && mapped.respond_to?(function)
-                mapped.send(function)
-              else
-                function.call(mapped)
-              end
-      assignments = { assign => value }
-      if child
-        child.beta_activate(Token.new(child, token, wme, assignments))
+    def evaluate(child: nil)
+      groups = if partition
+        tokens.group_by(&partition).values
       else
-        children.each do |beta|
-          beta.beta_activate(Token.new(beta, token, wme, assignments))
+        # just a single group of everything
+        [tokens]
+      end
+
+      groups.each do |tokens|
+        aggregated = self.aggregate.call(tokens.map(&self.map))
+        assignment = { var => aggregated }
+        children = child ? [child] : self.children
+        tokens.each do |token|
+          # TODO: optimize this to work with a diff of actual changes
+          beta_deactivate_children(token:, children:)
+          children.each do |beta|
+            beta.beta_activate(Token.new(beta, token, nil, assignment))
+          end
         end
       end
     end

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

@@ -25,7 +25,7 @@ module Wongi
         overlay.remove_token(token)
         return unless owner
 
-        ncc.ncc_activate owner if overlay.ncc_tokens_for(owner).empty?
+        ncc.ncc_activate(owner) if overlay.ncc_tokens_for(owner).empty?
       end
 
       def owner_for(token)

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

@@ -5,17 +5,16 @@ module Wongi
     class NegNode < BetaNode
       attr_reader :alpha, :tests
 
-      def initialize(parent, tests, alpha, unsafe)
+      def initialize(parent, tests, alpha)
         super(parent)
         @tests = tests
         @alpha = alpha
-        @unsafe = unsafe
       end
 
       def alpha_activate(wme, children: self.children)
         # p alpha_activate: {class: self.class, object_id:, wme:}
         tokens.each do |token|
-          next unless matches?(token, wme) && (@unsafe || !token.generated?(wme)) # feedback loop protection
+          next unless matches?(token, wme)
 
           # order matters for proper invalidation
           overlay.add_neg_join_result(NegJoinResult.new(token, wme))
@@ -71,8 +70,6 @@ module Wongi
         end
       end
 
-      protected
-
       def matches?(token, wme)
         puts "matching #{wme} against #{token}" if debug?
         @tests.each do |test|

data/lib/wongi-engine/compiler.rb

@@ -42,9 +42,9 @@ module Wongi::Engine
       node.tap(&:refresh)
     end
 
-    def neg_node(condition, tests, unsafe)
+    def neg_node(condition, tests)
       alpha = rete.compile_alpha(condition)
-      self.node = NegNode.new(node, tests, alpha, unsafe).tap do |node|
+      self.node = NegNode.new(node, tests, alpha).tap do |node|
         alpha.betas << node unless alpha_deaf
         node.refresh
       end
@@ -58,12 +58,9 @@ module Wongi::Engine
       end
     end
 
-    def aggregate_node(condition, tests, assignment, map, function, assign)
-      declare(assign)
-      alpha = rete.compile_alpha(condition)
-      self.node = AggregateNode.new(node, alpha, tests, assignment, map, function, assign).tap do |node|
-        alpha.betas << node unless alpha_deaf
-      end.tap(&:refresh)
+    def aggregate_node(var, over, partition, aggregate, map)
+      declare(var)
+      self.node = AggregateNode.new(node, var, over, partition, aggregate, map).tap(&:refresh)
     end
 
     def or_node(variants)

data/lib/wongi-engine/dsl/action/statement_generator.rb

@@ -1,3 +1,5 @@
+require "set"
+
 module Wongi::Engine
   module DSL::Action
     class StatementGenerator < BaseAction
@@ -16,23 +18,45 @@ module Wongi::Engine
         subject, predicate, object = template.resolve!(token)
 
         wme = WME.new(subject, predicate, object)
-
-        origin = GeneratorOrigin.new(token, self)
+        wme = overlay.find(wme) || wme
 
         production.tracer.trace(action: self, wme: wme) if production.tracer
-        if (existing = overlay.find(wme))
-          # do not mark purely manual tokens as generated, because a circular rule such as the symmetric friend generator this would cause both sides to become self-sustaining
-          # TODO: but this may have to be smarter, because there may be more indirect ways of creating such a situation
-          if overlay.generated?(wme)
-            token.generated_wmes << existing
-            overlay.assert(existing, generator: origin)
-          end
-        else
+
+        if should_assert?(wme, token)
+          origin = GeneratorOrigin.new(token, self)
           token.generated_wmes << wme
           overlay.assert(wme, generator: origin)
         end
       end
 
+      private def should_assert?(wme, token)
+        considered_tokens = Set.new
+        tokens_to_consider = [token]
+        until tokens_to_consider.empty?
+          token = tokens_to_consider.shift
+          considered_tokens.add(token)
+
+          # self-affirming reasoning
+          return false if token.wme == wme
+
+          # asserting this WME would invalidate the match
+          return false if token.node.is_a?(NegNode) && token.node.matches?(token, wme)
+
+          if token.parent && !considered_tokens.include?(token.parent)
+            tokens_to_consider.push(token.parent)
+          end
+
+          if token.wme
+            overlay.generators(token.wme).each do |generator|
+              tokens_to_consider.push(generator.token) unless considered_tokens.include?(generator.token)
+            end
+          end
+        end
+
+        # we could not prove that the new WME should not be asserted
+        true
+      end
+
       def deexecute(token)
         origin = GeneratorOrigin.new(token, self)
 

data/lib/wongi-engine/dsl/clause/aggregate.rb

@@ -1,20 +1,18 @@
 module Wongi::Engine
   module DSL::Clause
-    class Aggregate < Has
-      attr_reader :map, :function, :assign
+    class Aggregate
+      attr_reader :var, :over, :partition, :aggregate, :map
 
-      def initialize(s, p, o, options = {})
-        member = options[:on]
+      def initialize(var, options = {})
+        @var = var
+        @over = options[:over]
+        @partition = options[:partition]
+        @aggregate = options[:using]
         @map = options[:map]
-        @function = options[:function]
-        @assign = options[:assign]
-        @map ||= ->(wme) { wme.send(member) }
-        super
       end
 
       def compile(context)
-        tests, assignment = parse_variables(context)
-        context.tap { |c| c.aggregate_node(self, tests, assignment, map, function, assign) }
+        context.tap { |c| c.aggregate_node(var, over, partition, aggregate, map) }
       end
     end
   end

data/lib/wongi-engine/dsl/clause/fact.rb

@@ -5,7 +5,6 @@ module Wongi::Engine
       attr_predicate :debug
 
       def initialize(s, p, o, options = {})
-        @unsafe = options[:unsafe] || false
         debug! if options[:debug]
         super(s, p, o)
       end
@@ -43,13 +42,11 @@ module Wongi::Engine
     end
 
     class Neg < Has
-      attr_reader :unsafe
-
       def compile(context)
         tests, assignment = parse_variables(context)
         raise DefinitionError, "Negative matches may not introduce new variables: #{assignment.variables}" unless assignment.root?
 
-        context.tap { |c| c.neg_node(self, tests, unsafe) }
+        context.tap { |c| c.neg_node(self, tests) }
       end
 
       def inspect

data/lib/wongi-engine/dsl.rb

@@ -89,19 +89,29 @@ module Wongi::Engine::DSL
     clause :aggregate
     accept Clause::Aggregate
 
-    clause :least, :min
-    body { |s, p, o, opts|
-      aggregate s, p, o, on: opts[:on], function: :min, assign: opts[:assign]
+    clause :min
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.min })
     }
 
-    clause :greatest, :max
-    body { |s, p, o, opts|
-      aggregate s, p, o, on: opts[:on], function: :max, assign: opts[:assign]
+    clause :max
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.max })
     }
 
     clause :count
-    body { |s, p, o, opts|
-      aggregate s, p, o, map: ->(_) { 1 }, function: ->(collection) { collection.inject(&:+) }, assign: opts[:assign]
+    body { |var, opts = {}|
+      aggregate var, opts.merge(using: ->(collection) { collection.count })
+    }
+
+    clause :sum
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.inject(:+) })
+    }
+
+    clause :product
+    body { |var, opts|
+      aggregate var, opts.merge(using: ->(collection) { collection.inject(:*) })
     }
 
     clause :assert, :dynamic

data/lib/wongi-engine/token.rb

@@ -40,6 +40,10 @@ module Wongi::Engine
       a.respond_to?(:call) ? a.call(self) : a
     end
 
+    def values_at(*vars)
+      vars.map { self[_1] }
+    end
+
     def has_var?(x)
       assignments.key? x
     end

data/lib/wongi-engine/version.rb

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

data/spec/action_class_spec.rb

@@ -23,7 +23,7 @@ describe 'action classes' do
     end
   end
 
-  it 'should have appropriate callbacks executed' do
+  it 'has appropriate callbacks executed' do
     executed = 0
     deexecuted = 0
 

data/spec/aggregate_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'aggregate' do
+  include Wongi::Engine::DSL
+
+  let(:engine) { Wongi::Engine.create }
+  let(:rule_name) { SecureRandom.alphanumeric(16) }
+  let(:production) { engine.productions[rule_name] }
+
+  context 'min' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          has :_, :weight, :Weight
+          min :X, over: :Weight
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
+      end
+
+      engine.retract [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
+    end
+  end
+
+  context 'max' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          has :_, :weight, :Weight
+          max :X, over: :Weight
+          has :Fruit, :weight, :X
+        }
+      end
+
+      engine << [:pea, :weight, 2]
+      expect(production.size).to be == 1
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
+      end
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 5
+        expect(token[:Fruit]).to be == :apple
+      end
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 1
+      production.tokens.each do |token|
+        expect(token[:X]).to be == 2
+        expect(token[:Fruit]).to be == :pea
+      end
+    end
+  end
+
+  context 'count' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          has :_, :weight, :Weight
+          count :Count
+        }
+      end
+
+      engine << [:pea, :weight, 1]
+      expect(production.size).to be == 1
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 1
+      end
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 2
+      end
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 3
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 3
+      end
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 2
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 2
+      end
+    end
+
+    it 'works with a post-filter' do
+      engine << rule(rule_name) do
+        forall {
+          has :_, :weight, :Weight
+          count :Count
+          gte :Count, 3 # pass if at least 3 matching facts exist
+        }
+      end
+
+      engine << [:pea, :weight, 1]
+      expect(production.size).to be == 0
+
+      engine << [:apple, :weight, 5]
+      expect(production.size).to be == 0
+
+      engine << [:watermelon, :weight, 15]
+      expect(production.size).to be == 3
+      production.tokens.each do |token|
+        expect(token[:Count]).to be == 3
+      end
+
+      engine.retract [:apple, :weight, 5]
+      expect(production.size).to be == 0
+    end
+  end
+
+  context 'partitioning by a single var' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          has :factor, :Number, :Factor
+          product :Product, over: :Factor, partition: :Number
+        }
+      end
+
+      engine << [:factor, 10, 2]
+      engine << [:factor, 10, 5]
+      engine << [:factor, 12, 3]
+      engine << [:factor, 12, 4]
+
+      expect(production).to have(4).tokens
+      production.tokens.each do |token|
+        expect(token[:Product]).to be_a(Integer)
+        expect(token[:Product]).to eq(token[:Number])
+      end
+    end
+  end
+
+  context 'partitioning by a list' do
+    it 'works' do
+      engine << rule(rule_name) do
+        forall {
+          has :factor, :Number, :Factor
+          product :Product, over: :Factor, partition: [:Number]
+        }
+      end
+
+      engine << [:factor, 10, 2]
+      engine << [:factor, 10, 5]
+      engine << [:factor, 12, 3]
+      engine << [:factor, 12, 4]
+
+      expect(production).to have(4).tokens
+      production.tokens.each do |token|
+        expect(token[:Product]).to be_a(Integer)
+        expect(token[:Product]).to eq(token[:Number])
+      end
+    end
+  end
+end

data/spec/{rule_specs/any_rule_spec.rb → any_rule_spec.rb}

@@ -6,7 +6,7 @@ describe "ANY rule" do
   let(:engine) { Wongi::Engine.create }
 
   context "with just one option" do
-    it "should act like a positive matcher" do
+    it "acts like a positive matcher" do
       engine << rule('one-option') {
         forall {
           any {
@@ -43,17 +43,17 @@ describe "ANY rule" do
       end
     end
 
-    it 'should fire on the first path' do
+    it 'fires 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
+    it 'fires 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
+    it 'fires 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

data/spec/{filter_specs/assert_test_spec.rb → assert_test_spec.rb}

@@ -10,7 +10,7 @@ describe "ASSERT test" do
     @production = (engine << rule('test-rule', &block))
   end
 
-  it "should pass with a constant 'true'" do
+  it "passes with a constant 'true'" do
     test_rule {
       forall {
         assert { |_token|
@@ -22,7 +22,7 @@ describe "ASSERT test" do
     expect(production).to have(1).token
   end
 
-  it "should fail with a constant 'false'" do
+  it "fails with a constant 'false'" do
     test_rule {
       forall {
         assert { |_token|
@@ -34,7 +34,7 @@ describe "ASSERT test" do
     expect(production).to have(0).tokens
   end
 
-  it "should use the token with no arguments" do
+  it "uses the token with no arguments" do
     test_rule {
       forall {
         has :X, "is", :Y
@@ -50,7 +50,7 @@ describe "ASSERT test" do
     expect(production.tokens.first[:X]).to eq("resistance")
   end
 
-  it "should be retractable" do
+  it "is retractable" do
     test_rule {
       forall {
         has :X, "is", :Y
@@ -65,7 +65,7 @@ describe "ASSERT test" do
     expect(production).to have(0).tokens
   end
 
-  it "should use individual variables with arguments" do
+  it "uses individual variables with arguments" do
     test_rule {
       forall {
         has :X, "is", :Y