wongi-engine 0.3.5 → 0.3.7

data/lib/wongi-engine/token.rb

@@ -1,24 +1,23 @@
 module Wongi::Engine
-
   class Token
-
     include CoreExt
 
-    attr_reader :children
-    attr_reader :wme
-    attr_reader :node
-    attr_reader :overlay
+    attr_reader :children, :wme, :node, :overlay, :neg_join_results, :opt_join_results, :ncc_results, :generated_wmes
     attr_accessor :owner, :parent
-    attr_reader :neg_join_results
-    attr_reader :opt_join_results
-    attr_reader :ncc_results
-    attr_reader :generated_wmes
+
     attr_predicate :optional
     attr_predicate :deleted
 
-    def initialize node, token, wme, assignments
-      @node, @parent, @wme, @assignments = node, token, wme, assignments
-      @overlay = wme ? wme.overlay.highest(token.overlay) : (token ? token.overlay : node.rete.default_overlay)
+    def initialize(node, token, wme, assignments)
+      @node = node
+      @parent = token
+      @wme = wme
+      @assignments = assignments
+      @overlay = if wme
+                   wme.overlay.highest(token.overlay)
+                 else
+                   token ? token.overlay : node.rete.default_overlay
+                 end
       @children = []
       @deleted = false
       @neg_join_results = []
@@ -36,10 +35,8 @@ module Wongi::Engine
       end
     end
 
-    def subst variable, value
-      if @assignments.has_key? variable
-        @assignments[ variable ] = value
-      end
+    def subst(variable, value)
+      @assignments[variable] = value if @assignments.key? variable
     end
 
     def set(variable, value)
@@ -50,19 +47,20 @@ module Wongi::Engine
       all_assignments
     end
 
-    def [] var
-      if a = assignments[ var ]
-        a.respond_to?(:call) ? a.call( self ) : a
-      end
+    def [](var)
+      a = assignments[var]
+      return unless a
+
+      a.respond_to?(:call) ? a.call(self) : a
     end
 
-    def has_var? x
-      assignments.has_key? x
+    def has_var?(x)
+      assignments.key? x
     end
 
-    # TODO ignore assignments?
-    def duplicate? other
-      self.parent.equal?(other.parent) && @wme.equal?(other.wme) && self.assignments == other.assignments
+    # TODO: ignore assignments?
+    def duplicate?(other)
+      parent.equal?(other.parent) && @wme.equal?(other.wme) && assignments == other.assignments
     end
 
     def to_s
@@ -89,27 +87,30 @@ module Wongi::Engine
     end
 
     # for neg feedback loop protection
-    def generated? wme
+    def generated?(wme)
       return true if generated_wmes.any? { |w| w == wme }
-      return children.any? { |t| t.generated? wme }
+
+      children.any? { |t| t.generated? wme }
     end
 
     protected
 
     def all_assignments
-      raise "Assignments is not a hash" unless @assignments.kind_of?( Hash )
+      raise "Assignments is not a hash" unless @assignments.is_a?(Hash)
+
       if @parent
         @parent.assignments.merge @assignments
       else
         @assignments
       end
     end
-
   end
 
   class FakeToken < Token
-    def initialize token, wme, assignments
-      @parent, @wme, @assignments = token, wme, assignments
+    def initialize(token, wme, assignments) # rubocop:disable Lint/MissingSuper
+      @parent = token
+      @wme = wme
+      @assignments = assignments
       @children = []
       @neg_join_results = []
       @opt_join_results = []
@@ -117,5 +118,4 @@ module Wongi::Engine
       @generated_wmes = []
     end
   end
-
 end

data/lib/wongi-engine/version.rb

@@ -1,5 +1,5 @@
 module Wongi
   module Engine
-    VERSION = "0.3.5"
+    VERSION = "0.3.7".freeze
   end
 end

data/lib/wongi-engine/wme.rb

@@ -1,7 +1,5 @@
 module Wongi::Engine
-
-  WME = Struct.new( :subject, :predicate, :object ) do
-
+  WME = Struct.new(:subject, :predicate, :object) do
     include CoreExt
 
     attr_reader :rete
@@ -9,11 +7,11 @@ module Wongi::Engine
     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
-
+    def initialize(s, p, o, r = nil)
       manual!
 
       @deleted = false
@@ -24,35 +22,33 @@ module Wongi::Engine
 
       @rete = r
 
-    # TODO: reintroduce Network#import when bringing back RDF support
-      super( s, p, o )
-
+      # 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|
+    def import_into(r)
+      self.class.new(subject, predicate, object, r).tap do |wme|
         wme.overlay = overlay
-        wme.manual = self.manual?
+        wme.manual = manual?
       end
     end
 
     def dup
-      self.class.new( subject, predicate, object, rete ).tap do |wme|
+      self.class.new(subject, predicate, object, rete).tap do |wme|
         wme.overlay = overlay
-        wme.manual = self.manual?
+        wme.manual = manual?
       end
     end
 
-    def == other
+    def ==(other)
       subject == other.subject && predicate == other.predicate && object == other.object
     end
 
-    def =~ template
-      raise Wongi::Engine::Error, "Cannot match a WME against a #{template.class}" unless Template === template
-      result = match_member( self.subject, template.subject ) & match_member( self.predicate, template.predicate ) & match_member( self.object, template.object )
-      if result.match?
-        result
-      end
+    def =~(template)
+      raise Wongi::Engine::Error, "Cannot match a WME against a #{template.class}" unless template.is_a?(Template)
+
+      result = match_member(subject, template.subject) & match_member(predicate, template.predicate) & match_member(object, template.object)
+      result if result.match?
     end
 
     def generated?
@@ -73,7 +69,7 @@ module Wongi::Engine
 
     protected
 
-    def match_member mine, theirs
+    def match_member(mine, theirs)
       result = WMEMatchData.new
       if theirs == :_ || mine == theirs
         result.match!
@@ -83,7 +79,5 @@ module Wongi::Engine
       end
       result
     end
-
   end
-
 end

data/lib/wongi-engine/wme_match_data.rb

@@ -1,19 +1,17 @@
 module Wongi::Engine
-
   class WMEMatchData
-
     attr_reader :assignments
 
-    def initialize assignments = { }, match = false
+    def initialize(assignments = {}, match = false)
       @assignments = assignments
       @match = match
     end
 
-    def [] key
+    def [](key)
       assignments[key]
     end
 
-    def []= key, value
+    def []=(key, value)
       assignments[key] = value
     end
 
@@ -25,10 +23,8 @@ module Wongi::Engine
       @match = true
     end
 
-    def & other
-      WMEMatchData.new( assignments.merge( other.assignments ), match? && other.match? )
+    def &(other)
+      WMEMatchData.new(assignments.merge(other.assignments), match? && other.match?)
     end
-
   end
-
 end

data/lib/wongi-engine.rb

@@ -1,19 +1,15 @@
 module Wongi
   module Engine
-    
     def self.create
       Network.new
     end
-
   end
 
   # pre-declare things to avoid undefined constants
   module RDF
-
     class Document; end
     class Statement; end
     class Node; end
-
   end
 end
 

data/spec/action_class_spec.rb

@@ -1,62 +1,56 @@
 require 'spec_helper'
 
-
 describe 'action classes' do
-
-	include Wongi::Engine::DSL
+  include Wongi::Engine::DSL
 
   let :engine do
-  	Wongi::Engine.create
+    Wongi::Engine.create
   end
 
   let :action_class do
-  	Class.new do
-  		class << self
-  			attr_accessor :execute_body
-  			attr_accessor :deexecute_body
-  		end
-
-  		def execute(token)
-  			self.class.execute_body.call(token)
-  		end
-
-  		def deexecute(token)
-  			self.class.deexecute_body.call(token)
-  		end
-  	end
+    Class.new do
+      class << self
+        attr_accessor :execute_body, :deexecute_body
+      end
+
+      def execute(token)
+        self.class.execute_body.call(token)
+      end
+
+      def deexecute(token)
+        self.class.deexecute_body.call(token)
+      end
+    end
   end
 
   it 'should have appropriate callbacks executed' do
-
-  	executed = 0
-  	deexecuted = 0
-
-  	klass = action_class
-
-  	klass.execute_body = lambda do |token|
-  		executed += 1
-  	end
-  	klass.deexecute_body = lambda do |token|
-  		deexecuted += 1
-  	end
-
-  	engine << rule {
-  		forall {
-  			has :A, :x, :B
-  		}
-  		make {
-  			action klass
-  		}
-  	}
-
-  	engine << [1, :x, 2]
-  	expect(executed).to be == 1
-  	expect(deexecuted).to be == 0
-
-  	engine.retract [1, :x, 2]
-  	expect(executed).to be == 1
-  	expect(deexecuted).to be == 1
-
+    executed = 0
+    deexecuted = 0
+
+    klass = action_class
+
+    klass.execute_body = lambda do |_token|
+      executed += 1
+    end
+    klass.deexecute_body = lambda do |_token|
+      deexecuted += 1
+    end
+
+    engine << rule {
+      forall {
+        has :A, :x, :B
+      }
+      make {
+        action klass
+      }
+    }
+
+    engine << [1, :x, 2]
+    expect(executed).to be == 1
+    expect(deexecuted).to be == 0
+
+    engine.retract [1, :x, 2]
+    expect(executed).to be == 1
+    expect(deexecuted).to be == 1
   end
-
 end

data/spec/beta_node_spec.rb

@@ -1,15 +1,12 @@
 require 'spec_helper'
 
 describe Wongi::Engine::BetaNode do
-
   include Wongi::Engine::DSL
 
-  let( :engine ) { Wongi::Engine.create }
+  let(:engine) { Wongi::Engine.create }
 
   describe '#tokens' do
-
     it 'should be enumerable' do
-
       production = engine << rule {
         forall {
           has :x, :y, :Z
@@ -20,10 +17,7 @@ describe Wongi::Engine::BetaNode do
       engine << [:x, :y, 2]
       engine << [:x, :y, 3]
       zs = production.tokens.map { |token| token[:Z] }
-      expect( zs ).to be == [1, 2, 3]
-
+      expect(zs).to be == [1, 2, 3]
     end
-
   end
-
 end

data/spec/bug_specs/issue_4_spec.rb

@@ -1,12 +1,10 @@
 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] }
+    10.times { |i| engine << [i, :is_number, true] }
 
     engine.rule 'segregate' do
       forall {
@@ -26,11 +24,9 @@ describe "issue 4" do
 
     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
@@ -46,22 +42,20 @@ describe "issue 4" do
       }
     end
 
-    10.times{ |i| engine << [i, :is_number, true] }
+    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] }
+    10.times { |i| engine << [i, :is_number, true] }
 
     engine.rule 'segregate' do
       forall {
@@ -70,7 +64,7 @@ describe "issue 4" do
       make {
         action { |token|
           number = token[:Number]
-          if number % 2 == 0
+          if number.even?
             engine << [number, :is_even, true]
             engine.retract [number, :is_number, true]
             engine.retract [number + 1, :is_number, true]
@@ -89,14 +83,12 @@ describe "issue 4" do
     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] }
+    10.times { |i| engine << [i, :is_number, true] }
 
     engine.rule 'find odds' do
       forall {
@@ -106,7 +98,7 @@ describe "issue 4" do
       make {
         action { |token|
           number = token[:Number]
-          if number % 2 != 0
+          if number.odd?
             engine << [number, :is_odd, true]
             engine.retract [number, :is_number, true]
           end
@@ -121,11 +113,11 @@ describe "issue 4" do
       make {
         action { |token|
           number = token[:Number]
-          if number % 2 == 0
-            engine << [number, :is_even, true]
-          else
-            engine << [number, :probably_odd, true]
-          end
+          engine << if number.even?
+                      [number, :is_even, true]
+                    else
+                      [number, :probably_odd, true]
+                    end
         }
       }
     end
@@ -134,7 +126,7 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    # numbers.should be_empty
+    expect(numbers.length).to eq(5)
     expect(evens.length).to eq(5)
     expect(odds.length).to eq(5)
   end

data/spec/dataset_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
 
-describe Wongi::Engine::Network do  
-
+describe Wongi::Engine::Network do
+  include Wongi::Engine::DSL
   it 'should expose compiled productions' do
-
     ds = Wongi::Engine::Network.new
 
     ds << rule('test-rule') {
@@ -20,8 +19,6 @@ describe Wongi::Engine::Network do
     ds << [1, 2, 3]
 
     expect(production.size).to eq(1)
-    expect( production.size ).to be == 1
-
+    expect(production.size).to be == 1
   end
-
 end

data/spec/filter_specs/assert_test_spec.rb

@@ -1,53 +1,40 @@
 require 'spec_helper'
 
 describe "ASSERT test" do
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  def engine
-    @engine
-  end
-
-  def production
-    @production
-  end
+  attr_reader :production
 
-  def test_rule &block
-    @production = ( engine << rule( 'test-rule', &block ) )
+  def test_rule(&block)
+    @production = (engine << rule('test-rule', &block))
   end
 
   it "should pass with a constant 'true'" do
-
     test_rule {
       forall {
-        assert { |token|
+        assert { |_token|
           true
         }
       }
     }
 
     expect(production).to have(1).token
-    
   end
 
   it "should fail with a constant 'false'" do
-
     test_rule {
       forall {
-        assert { |token|
+        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
@@ -57,15 +44,13 @@ describe "ASSERT test" do
       }
     }
 
-    engine << ["resistance", "is", "futile"]
+    engine << %w[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
@@ -75,28 +60,24 @@ describe "ASSERT test" do
       }
     }
 
-    engine << ["resistance", "is", "futile"]
-    engine.retract ["resistance", "is", "futile"]
+    engine << %w[resistance is futile]
+    engine.retract %w[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|
+        assert :X, :Y do |_x, y|
           y == "futile"
         end
       }
     }
 
-    engine << ["resistance", "is", "futile"]
+    engine << %w[resistance is futile]
 
     expect(production).to have(1).token
     expect(production.tokens.first[:X]).to eq("resistance")
-
   end
-
 end

data/spec/filter_specs/greater_than_equality_test_spec.rb

@@ -3,11 +3,8 @@
 require 'spec_helper'
 
 describe 'Greater Than Or Equal test' do
-  before :each do
-    @engine = Wongi::Engine.create
-  end
-
-  attr_reader :engine
+  include Wongi::Engine::DSL
+  let(:engine) { Wongi::Engine.create }
 
   attr_reader :production