mort666-wongi-engine 0.2.9

data/lib/wongi-engine/wme_match_data.rb

@@ -0,0 +1,34 @@
+module Wongi::Engine
+
+  class WMEMatchData
+
+    attr_reader :assignments
+
+    def initialize assignments = { }, match = false
+      @assignments = assignments
+      @match = match
+    end
+
+    def [] key
+      assignments[key]
+    end
+
+    def []= key, value
+      assignments[key] = value
+    end
+
+    def match?
+      @match
+    end
+
+    def match!
+      @match = true
+    end
+
+    def & other
+      WMEMatchData.new( assignments.merge( other.assignments ), match? && other.match? )
+    end
+
+  end
+
+end

data/spec/beta_node_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Wongi::Engine::BetaNode do
+
+  include Wongi::Engine::DSL
+
+  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/bug_specs/issue_4_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe "issue 4" do
+
+  it "should correctly retract pre-added items from within a rule" do
+
+    engine = Wongi::Engine.create
+
+    10.times{ |i| engine << [i, :is_number, true] }
+
+    engine.rule 'segregate' do
+      forall {
+        has :Number, :is_number, true
+      }
+      make {
+        action { |token|
+          number = token[:Number]
+          engine << [number, :is_even, true]
+          engine.retract [number, :is_number, true]
+        }
+      }
+    end
+
+    numbers = engine.select :_, :is_number, true
+    evens = engine.select :_, :is_even, true
+
+    expect(numbers).to be_empty
+    expect(evens.length).to eq(10)
+
+  end
+
+  it "should correctly retract post-added items from within a rule" do
+
+    engine = Wongi::Engine.create
+
+    engine.rule 'segregate' do
+      forall {
+        has :Number, :is_number, true
+      }
+      make {
+        action { |token|
+          number = token[:Number]
+          engine << [number, :is_even, true]
+          engine.retract [number, :is_number, true]
+        }
+      }
+    end
+
+    10.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)
+
+  end
+
+  # cascaded processing affects this
+  it "should not retract later items from within a rule" do
+
+    engine = Wongi::Engine.create
+
+    10.times{ |i| engine << [i, :is_number, true] }
+
+    engine.rule 'segregate' do
+      forall {
+        has :Number, :is_number, true
+      }
+      make {
+        action { |token|
+          number = token[:Number]
+          if number % 2 == 0
+            engine << [number, :is_even, true]
+            engine.retract [number, :is_number, true]
+            engine.retract [number + 1, :is_number, true]
+          else
+            # this is not reached without cascades
+            engine << [number, :is_odd, true]
+          end
+        }
+      }
+    end
+
+    numbers = engine.select :_, :is_number, true
+    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
+
+  end
+
+
+  it "should not lose track when another rule affects a set" do
+    engine = Wongi::Engine.create
+
+    10.times{ |i| engine << [i, :is_number, true] }
+
+    engine.rule 'find odds' do
+      forall {
+        has :Number, :is_number, true
+        has :Number, :probably_odd, true
+      }
+      make {
+        action { |token|
+          number = token[:Number]
+          if number % 2 != 0
+            engine << [number, :is_odd, true]
+            engine.retract [number, :is_number, true]
+          end
+        }
+      }
+    end
+    engine.rule 'find evens' do
+      forall {
+        has :Number, :is_number, true
+        neg :Number, :is_odd, true
+      }
+      make {
+        action { |token|
+          number = token[:Number]
+          if number % 2 == 0
+            engine << [number, :is_even, true]
+          else
+            engine << [number, :probably_odd, true]
+          end
+        }
+      }
+    end
+
+    numbers = engine.select :_, :is_number, true
+    evens = engine.select :_, :is_even, true
+    odds = engine.select :_, :is_odd, true
+
+    # numbers.should be_empty
+    expect(evens.length).to eq(5)
+    expect(odds.length).to eq(5)
+  end
+end

data/spec/dataset_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Wongi::Engine::Network do  
+
+  it 'should expose compiled productions' do
+
+    ds = Wongi::Engine::Network.new
+
+    ds << rule('test-rule') {
+      forall {
+        has 1, 2, 3
+      }
+    }
+
+    production = ds.productions['test-rule']
+    expect(production).not_to be_nil
+
+    expect(production).to be_empty
+
+    ds << [1, 2, 3]
+
+    expect(production.size).to eq(1)
+    expect( production.size ).to be == 1
+
+  end
+
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'DSL' do
+
+  it 'should register rulesets globally' do
+
+  end
+
+end

data/spec/filter_specs/assert_test_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe "ASSERT test" do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  def production
+    @production
+  end
+
+  def test_rule &block
+    @production = ( engine << rule( 'test-rule', &block ) )
+  end
+
+  it "should pass with a constant 'true'" do
+
+    test_rule {
+      forall {
+        assert { |token|
+          true
+        }
+      }
+    }
+
+    expect(production).to have(1).token
+    
+  end
+
+  it "should fail with a constant 'false'" do
+
+    test_rule {
+      forall {
+        assert { |token|
+          false
+        }
+      }
+    }
+
+    expect(production).to have(0).tokens
+
+  end
+
+  it "should use the token with no arguments" do
+
+    test_rule {
+      forall {
+        has :X, "is", :Y
+        assert { |token|
+          token[:X] == "resistance"
+        }
+      }
+    }
+
+    engine << ["resistance", "is", "futile"]
+
+    expect(production).to have(1).token
+    expect(production.tokens.first[:X]).to eq("resistance")
+
+  end
+
+  it "should be retractable" do
+
+    test_rule {
+      forall {
+        has :X, "is", :Y
+        assert { |token|
+          token[:X] == "resistance"
+        }
+      }
+    }
+
+    engine << ["resistance", "is", "futile"]
+    engine.retract ["resistance", "is", "futile"]
+    expect(production).to have(0).tokens
+
+  end
+
+  it "should use individual variables with arguments" do
+
+    test_rule {
+      forall {
+        has :X, "is", :Y
+        assert :X, :Y do |x, y|
+          y == "futile"
+        end
+      }
+    }
+
+    engine << ["resistance", "is", "futile"]
+
+    expect(production).to have(1).token
+    expect(production.tokens.first[:X]).to eq("resistance")
+
+  end
+
+end

data/spec/filter_specs/less_test_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "LESS test" do
+
+  before :each do
+    @engine = Wongi::Engine.create
+  end
+
+  def engine
+    @engine
+  end
+
+  def production
+    @production
+  end
+
+  def test_rule &block
+    @production = ( engine << rule( 'test-rule', &block ) )
+  end
+
+  it "should interact with optional node correctly" do
+
+    # before the fix, filters would try to piggy-back on optional templates
+
+    test_rule {
+      forall {
+        maybe "Z", "Z", "Z"
+        less 6,4 # this should fail
+      }
+
+      make {
+        gen ".", ".", "."
+      }
+    }
+
+    engine << ["A", "B", "C"]
+
+    expect(@production.size).to eq(0)
+  end
+
+end

data/spec/generation_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Wongi::Engine::DSL::Action::StatementGenerator do
+
+  let( :engine ) { Wongi::Engine.create }
+
+  let( :transitive_rule ) {
+    rule {
+      forall {
+        has :P, :transitive, true
+        has :X, :P, :Y
+        has :Y, :P, :Z
+      }
+      make {
+        gen :X, :P, :Z
+      }
+    }
+  }
+
+  let( :production ) { engine << transitive_rule }
+
+  shared_examples 'generation' do
+
+    it 'should generate facts' do
+      engine << %w( Alice relative Bob )
+      engine << %w( Bob relative Dwight )
+
+      expect( production ).to have(1).token
+      expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+    end
+
+    it 'should retrct generated facts' do
+      engine << %w( Alice relative Bob )
+      engine << %w( Bob relative Dwight )
+      engine.retract %w( Bob relative Dwight )
+
+      expect( production ).to have(0).tokens
+      expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+    end
+
+    context 'transitive diamond' do
+
+      before :each do
+        engine << %w( Alice relative Bob )
+        engine << %w( Bob relative Dwight )
+        engine << %w( Alice relative Claire )
+        engine << %w( Claire relative Dwight )
+      end
+
+      it 'should be created' do
+        expect( production ).to have(2).tokens
+        expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+      end
+
+      it 'should remain after a single retraction' do
+        engine.retract %w( Claire relative Dwight )
+
+        expect( production ).to have(1).token
+        expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+      end
+
+      it 'should be destroyed after both retractions' do
+        engine.retract %w( Claire relative Dwight )
+        engine.retract %w( Alice relative Bob )
+
+        expect( production ).to have(0).tokens
+        expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+      end
+
+    end
+
+  end
+
+  context "pre-asserted", :pre do
+
+    before :each do
+      engine << [ "relative", :transitive, true ]
+    end
+
+    it_behaves_like 'generation'
+
+  end
+
+  context "post-asserted", :post do
+
+    before :each do
+      production
+      engine << [ "relative", :transitive, true ]
+    end
+
+    it_behaves_like 'generation'
+
+    it 'should not retract generated facts marked as manual', :wip do
+      engine << %w( Alice relative Bob )
+      engine << %w( Bob relative Dwight )
+      engine << %w( Alice relative Dwight )
+      engine.retract %w( Alice relative Bob )
+
+      expect( production ).to have(0).tokens
+      expect( engine.find *%w( Alice relative Dwight ) ).not_to be_nil
+    end
+
+    it 'should retract generated facts unmarked as manual', :wip do
+      engine << %w( Alice relative Bob )
+      engine << %w( Bob relative Dwight )
+      engine << %w( Alice relative Dwight )
+      engine.retract %w( Alice relative Dwight )
+      engine.retract %w( Alice relative Bob )
+
+      expect( production ).to have(0).tokens
+      expect( engine.find *%w( Alice relative Dwight ) ).to be_nil
+    end
+
+  end
+
+end