wongi-engine 0.4.0.pre.alpha5 → 0.4.0.pre.alpha6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 279bf4d4b1203e706faa3671e0e74ea20ee52d6236280fa8a7b878abe4df1aee
-  data.tar.gz: dc3a03595e87e552564c25aa47710cdb036c72a55dde73c00d913544398d6300
+  metadata.gz: 4fab0e9a6fff37b3dc1a6cb4e7aa2c10ea08c82dbe78c874a7d475a18dfef170
+  data.tar.gz: e23cedb3481395ff240868b45eeedc5854331f521c3c00e96ff6e537d2e7c7e5
 SHA512:
-  metadata.gz: 561a05b7b122d4c3e7ac3c0b4cccc80f3cb4a1e74620f69f32d2f17e66054f0ed83dbc196996d3e5cbf9b394740643dd3f5501d512b1014e638b34ab1385b06d
-  data.tar.gz: 3fd398dbda7b5c0b41dc100ed2c4dbe19aaad939561e3c1dbf30bae8d83ecb76ea3d3720005bfe75f5cb80c4f0a430869894d59c12e735653814367b4235b58c
+  metadata.gz: 9344af4983e233a95b157b4877f432f17fc7068a6ae77de4ca4edb5678e3555fb079dc13c8dee1866b21a09afcb4c003077ff8e70d7ad1222605ceab828d7726
+  data.tar.gz: cda25e408f9ba4706002d476f1c03cc367d10dddaf6381736b27f17be9b9e6b43e2993c9d84947d8eee3e04d08e631ba79a31332948f08b7ee44ecf95fd17ffc

data/.rubocop.yml

@@ -75,3 +75,12 @@ Style/OptionalBooleanParameter:
 
 Gemspec/RequiredRubyVersion:
   Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ContextWording:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false

data/lib/wongi-engine/alpha_index.rb

@@ -16,10 +16,9 @@ module Wongi::Engine
     def remove(wme)
       collection = collection_for_wme(wme)
       collection.delete(wme)
-      if collection.empty?
-        # release some memory
-        index.delete(hashed_key(wme))
-      end
+
+      # release some memory
+      index.delete(hashed_key(wme)) if collection.empty?
     end
 
     def collection_for_wme(wme)

data/lib/wongi-engine/overlay.rb

@@ -183,14 +183,16 @@ module Wongi::Engine
         case operation
         when :assert
           wme = find_ignoring_hidden(wme) || wme
+          visible = !find(wme).nil?
           add_wme(wme, **options)
-          rete.real_assert(wme)
+          rete.real_assert(wme) unless visible
         when :retract
           wme = find_ignoring_hidden(wme)
           return if wme.nil? # it's perhaps better to return quietly, because complicated cascades may delete a WME while we're going through the queue
 
+          visible = !find(wme).nil?
           remove_wme(wme, **options)
-          rete.real_retract(wme)
+          rete.real_retract(wme) if visible
         end
       end
     end

data/lib/wongi-engine/version.rb

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

data/spec/dataset_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
   it 'exposes compiled productions' do
-    ds = Wongi::Engine::Network.new
+    ds = Wongi::Engine.create
 
     ds << rule('test-rule') {
       forall {

data/spec/greater_than_equality_test_spec.rb

@@ -2,29 +2,23 @@
 
 require 'spec_helper'
 
-describe 'Greater Than Or Equal test' do
+describe Wongi::Engine::GreaterThanOrEqualTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 
-  attr_reader :production
-
-  def test_rule(&block)
-    @production = (engine << rule('test-rule', &block))
-  end
-
   it 'interacts with optional node correctly' do
     # before the fix, filters would try to piggy-back on optional templates
 
-    test_rule do
-      forall do
+    production = engine << rule {
+      forall {
         has :Number, :assign_check, :_
         gte :Number, 6
-      end
-    end
+      }
+    }
 
     engine << [6, :assign_check, nil]
     engine << [7, :assign_check, nil]
     engine << [5, :assign_check, nil]
-    expect(@production.size).to eq(2)
+    expect(production.size).to eq(2)
   end
 end

data/spec/high_level_spec.rb

@@ -10,7 +10,7 @@ class << self
   }
 end
 
-describe 'the engine' do
+describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 

data/spec/less_test_spec.rb

@@ -1,19 +1,13 @@
 require 'spec_helper'
 
-describe "LESS test" do
+describe Wongi::Engine::LessThanTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 
-  attr_reader :production
-
-  def test_rule(&block)
-    @production = (engine << rule('test-rule', &block))
-  end
-
   it "interacts with optional node correctly" do
     # before the fix, filters would try to piggy-back on optional templates
 
-    test_rule {
+    production = engine << rule {
       forall {
         maybe "Z", "Z", "Z"
         less 6, 4 # this should fail
@@ -26,6 +20,6 @@ describe "LESS test" do
 
     engine << %w[A B C]
 
-    expect(@production.size).to eq(0)
+    expect(production.size).to eq(0)
   end
 end

data/spec/less_than_equality_test_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe 'Less Than Or Equal test' do
+describe Wongi::Engine::LessThanOrEqualTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 

data/spec/network_spec.rb

@@ -3,62 +3,60 @@ require 'spec_helper'
 describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
 
-  subject { engine }
-
   let(:engine) { Wongi::Engine.create }
 
   it 'asserts facts' do
-    subject << [1, 2, 3]
-    expect(subject.select(:_, 2, :_)).to have(1).item
+    engine << [1, 2, 3]
+    expect(engine.select(:_, 2, :_)).to have(1).item
   end
 
   it 'retracts facts' do
-    subject << [1, 2, 3]
-    subject.retract [1, 2, 3]
-    expect(subject.select(:_, 2, :_).count).to eq(0)
+    engine << [1, 2, 3]
+    engine.retract [1, 2, 3]
+    expect(engine.select(:_, 2, :_).count).to eq(0)
   end
 
   it 'asserted facts end up in productions' do
-    prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1, 2, 3]
+    prod = engine << rule { forall { has :X, 2, :Z } }
+    engine << [1, 2, 3]
     expect(prod).to have(1).tokens
   end
 
   it 'rules can be removed from engine' do
-    subject << [1, 2, 3]
-    subject << [4, 5, 6]
+    engine << [1, 2, 3]
+    engine << [4, 5, 6]
 
-    prod1 = subject << rule { forall { has :X, 2, :Z } }
-    prod2 = subject << rule { forall { has :X, 5, :Z } }
+    prod1 = engine << rule { forall { has :X, 2, :Z } }
+    prod2 = engine << rule { forall { has :X, 5, :Z } }
 
     expect(prod1).to have(1).tokens
     expect(prod2).to have(1).tokens
 
-    subject.remove_production(prod1)
+    engine.remove_production(prod1)
 
     expect(prod1).to have(0).tokens
     expect(prod2).to have(1).tokens
   end
 
   it 'new rules can be added to engine after a rule has been been removed' do
-    subject << [1, 2, 3]
-    subject << [4, 5, 6]
+    engine << [1, 2, 3]
+    engine << [4, 5, 6]
 
-    prod1 = subject << rule { forall { has :X, 2, :Z } }
+    prod1 = engine << rule { forall { has :X, 2, :Z } }
 
     expect(prod1).to have(1).tokens
 
-    subject.remove_production(prod1)
+    engine.remove_production(prod1)
     expect(prod1).to have(0).tokens
 
-    prod2 = subject << rule { forall { has :X, 5, :Z } }
+    prod2 = engine << rule { forall { has :X, 5, :Z } }
     expect(prod2).to have(1).tokens
   end
 
   it 'retracted facts are removed from productions' do
-    prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1, 2, 3]
-    subject.retract [1, 2, 3]
+    prod = engine << rule { forall { has :X, 2, :Z } }
+    engine << [1, 2, 3]
+    engine.retract [1, 2, 3]
     expect(prod).to have(0).tokens
   end
 
@@ -66,17 +64,17 @@ describe Wongi::Engine::Network do
     activated_z = nil
     deactivated_z = nil
 
-    subject << rule {
+    engine << rule {
       forall { has :X, 2, :Z }
       make {
         action activate: ->(token) { activated_z = token[:Z] },
                deactivate: ->(token) { deactivated_z = token[:Z] }
       }
     }
-    subject << [1, 2, 3]
+    engine << [1, 2, 3]
     expect(activated_z).to be == 3
 
-    subject.retract [1, 2, 3]
+    engine.retract [1, 2, 3]
     expect(deactivated_z).to be == 3
   end
 

data/spec/ruleset_spec.rb

@@ -2,44 +2,44 @@ require 'spec_helper'
 
 describe Wongi::Engine::Ruleset do
   before do
-    Wongi::Engine::Ruleset.reset
+    described_class.reset
   end
 
   context 'initially' do
     it 'has no rules' do
-      expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+      expect(described_class.rulesets).to be_empty
     end
   end
 
   context 'when creating' do
     it 'does not register itself when not given a name' do
-      ruleset = Wongi::Engine::Ruleset.new
+      ruleset = described_class.new
       expect(ruleset.name).to be_nil
-      expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+      expect(described_class.rulesets).to be_empty
     end
 
     it 'has a name' do
-      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
+      ruleset = described_class.new 'testing-ruleset'
       expect(ruleset.name).to be == 'testing-ruleset'
     end
 
     it 'registers itself when given a name' do
-      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
-      expect(Wongi::Engine::Ruleset.rulesets).not_to be_empty
-      expect(Wongi::Engine::Ruleset[ruleset.name]).to be == ruleset
+      ruleset = described_class.new 'testing-ruleset'
+      expect(described_class.rulesets).not_to be_empty
+      expect(described_class[ruleset.name]).to be == ruleset
     end
   end
 
   it 'is able to clear registered rulesets' do
-    _ = Wongi::Engine::Ruleset.new 'testing-ruleset'
-    Wongi::Engine::Ruleset.reset
-    expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+    _ = described_class.new 'testing-ruleset'
+    described_class.reset
+    expect(described_class.rulesets).to be_empty
   end
 
   it 'installs creating rules into a rete' do
     rete = double 'rete'
 
-    ruleset = Wongi::Engine::Ruleset.new
+    ruleset = described_class.new
     rule = ruleset.rule('test-rule') {}
 
     expect(rete).to receive(:<<).with(rule).once

data/spec/wme_spec.rb

@@ -9,36 +9,36 @@ describe Wongi::Engine::WME do
   #   rete
   # end
 
-  subject {
-    Wongi::Engine::WME.new "a", "b", "c"
+  let(:wme) {
+    described_class.new "a", "b", "c"
   }
 
   context 'a new WME' do
     it 'initializes and expose members' do
-      expect(subject.subject).to be == "a"
-      expect(subject.predicate).to be == "b"
-      expect(subject.object).to be == "c"
+      expect(wme.subject).to be == "a"
+      expect(wme.predicate).to be == "b"
+      expect(wme.object).to be == "c"
     end
   end
 
   it 'compares instances' do
-    wme1 = Wongi::Engine::WME.new "a", "b", "c"
-    wme2 = Wongi::Engine::WME.new "a", "b", "c"
-    wme3 = Wongi::Engine::WME.new "a", "b", "d"
+    wme1 = described_class.new "a", "b", "c"
+    wme2 = described_class.new "a", "b", "c"
+    wme3 = described_class.new "a", "b", "d"
 
     expect(wme1).to be == wme2
     expect(wme1).not_to be == wme3
   end
 
   it 'does not match against non-templates' do
-    expect { subject =~ [1, 2, 3] }.to raise_error(Wongi::Engine::Error)
+    expect { wme =~ [1, 2, 3] }.to raise_error(Wongi::Engine::Error)
   end
 
   it 'matches against templates' do
     t1 = Wongi::Engine::Template.new "a", :_, :_
     t2 = Wongi::Engine::Template.new "b", :_, :_
 
-    expect(subject).to be =~ t1
-    expect(subject).not_to be =~ t2
+    expect(wme).to be =~ t1
+    expect(wme).not_to be =~ t2
   end
 end

data/wongi-engine.gemspec

@@ -5,26 +5,30 @@ module GemHelper
   def self.git?
     File.exist?('.git')
   end
-
-  def self.hg?
-    File.exist?('.hg')
-  end
 end
 
 Gem::Specification.new do |gem|
-  gem.authors       = ['Valeri Sokolov']
-  gem.email         = ['ulfurinn@ulfurinn.net']
-  gem.description   = 'A rule engine.'
-  gem.summary       = 'A forward-chaining rule engine in pure Ruby.'
-  gem.homepage      = 'https://github.com/ulfurinn/wongi-engine'
-  gem.licenses      = %w[MIT]
+  gem.authors = ['Valeri Sokolov']
+  gem.email   = ['ulfurinn@ulfurinn.net']
+
+  gem.description = 'A forward-chaining rule engine in pure Ruby.'
+  gem.summary     = 'A forward-chaining rule engine in pure Ruby.'
+
+  gem.required_ruby_version = '>= 2.7.0'
+
+  gem.licenses = %w[MIT]
+
+  gem.homepage = 'https://github.com/ulfurinn/wongi-engine'
+  gem.metadata = {
+    "documentation_uri"     => 'https://ulfurinn.github.io/wongi-engine/',
+    "rubygems_mfa_required" => 'true',
+  }
+
 
   gem.files = if GemHelper.git?
                 `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-              elsif GemHelper.hg?
-                `hg st -cn`.split($OUTPUT_RECORD_SEPARATOR)
               else
-                raise 'cannot enumerate files: not a git or hg repository'
+                raise 'cannot enumerate files: not a git repository'
               end
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.name          = 'wongi-engine'
@@ -36,5 +40,4 @@ Gem::Specification.new do |gem|
   # gem.add_development_dependency 'pry-byebug', '~> 2.0'
   gem.add_development_dependency 'rspec', '~> 3.1'
   gem.add_development_dependency 'rspec-collection_matchers', '~> 1.1'
-  gem.metadata['rubygems_mfa_required'] = 'true'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.alpha5
+  version: 0.4.0.pre.alpha6
 platform: ruby
 authors:
 - Valeri Sokolov
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-description: A rule engine.
+description: A forward-chaining rule engine in pure Ruby.
 email:
 - ulfurinn@ulfurinn.net
 executables: []
@@ -180,6 +180,7 @@ homepage: https://github.com/ulfurinn/wongi-engine
 licenses:
 - MIT
 metadata:
+  documentation_uri: https://ulfurinn.github.io/wongi-engine/
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -189,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"