wongi-engine 0.3.6 → 0.3.7

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

@@ -1,140 +1,126 @@
 module Wongi
   module Engine
-
     TokenAssignment = Struct.new(:wme, :field) do
-      def call token = nil
+      def call(_token = nil)
         wme.send field
       end
+
       def inspect
         "#{field} of #{wme}"
       end
+
       def to_s
         inspect
       end
     end
 
     class BetaTest
+      attr_reader :field, :variable
 
-      attr_reader :field
-      attr_reader :variable
-
-      def initialize field, variable
-        @field, @variable = field, variable
+      def initialize(field, variable)
+        @field = field
+        @variable = variable
       end
 
-      def matches? token, wme
-        assignment = token[ self.variable ]
-        field = wme.send( self.field )
-        #field.nil? ||
-        !token.has_var?(self.variable) || field == assignment
+      def matches?(token, wme)
+        assignment = token[variable]
+        field = wme.send(self.field)
+        # field.nil? ||
+        !token.has_var?(variable) || field == assignment
       end
 
-      def equivalent? other
-        other.field == self.field && other.variable == self.variable
+      def equivalent?(other)
+        other.field == field && other.variable == variable
       end
-
     end
 
     class JoinNode < BetaNode
-
       attr_accessor :alpha
-      attr_reader :tests
-      attr_reader :assignment_pattern
+      attr_reader :tests, :assignment_pattern
 
-      def initialize parent, tests, assignment
+      def initialize(parent, tests, assignment)
         super(parent)
         @tests = tests
         @assignment_pattern = assignment
       end
 
-      def equivalent? alpha, tests, assignment_pattern
+      def equivalent?(alpha, tests, assignment_pattern)
         return false unless self.alpha == alpha
         return false unless self.assignment_pattern == assignment_pattern
-        return false unless (self.tests.empty? && tests.empty?) || self.tests.length == tests.length && self.tests.all? { |my_test|
+        return false unless (self.tests.empty? && tests.empty?) || (self.tests.length == tests.length && self.tests.all? { |my_test|
           tests.any? { |new_test|
             my_test.equivalent? new_test
           }
-        }
+        })
+
         true
       end
 
-      def alpha_activate wme
-        assignments = collect_assignments( wme )
+      def alpha_activate(wme)
+        assignments = collect_assignments(wme)
         parent.tokens.each do |token|
-          if matches?( token, wme )
-            children.each do |beta|
-              beta.beta_activate Token.new( beta, token, wme, assignments )
-            end
+          next unless matches?(token, wme)
+
+          children.each do |beta|
+            beta.beta_activate Token.new(beta, token, wme, assignments)
           end
         end
       end
 
-      def alpha_deactivate wme
+      def alpha_deactivate(wme)
         children.each do |child|
           child.tokens.each do |token|
-            if token.wme == wme
-              child.beta_deactivate token
-            end
+            child.beta_deactivate token if token.wme == wme
           end
         end
       end
 
-      def beta_activate token
-        self.alpha.wmes.each do |wme|
-          if matches?( token, wme )
-            assignments = collect_assignments( wme )
-            children.each do |beta|
-              beta.beta_activate Token.new( beta, token, wme, assignments )
-            end
+      def beta_activate(token)
+        alpha.wmes.each do |wme|
+          next unless matches?(token, wme)
+
+          assignments = collect_assignments(wme)
+          children.each do |beta|
+            beta.beta_activate Token.new(beta, token, wme, assignments)
           end
         end
       end
 
-      def beta_deactivate token
+      def beta_deactivate(token)
         children.each do |child|
           child.tokens.each do |t|
-            if t.parent == token
-              child.beta_deactivate t
-            end
+            child.beta_deactivate t if t.parent == token
           end
         end
       end
 
-      def refresh_child child
+      def refresh_child(child)
         alpha.wmes.each do |wme|
-          assignments = collect_assignments( wme )
+          assignments = collect_assignments(wme)
           parent.tokens.each do |token|
-            if matches?( token, wme )
-              child.beta_activate Token.new( child, token, wme, assignments )
-            end
+            child.beta_activate Token.new(child, token, wme, assignments) if matches?(token, wme)
           end
         end
       end
 
       protected
 
-      def matches? token, wme
+      def matches?(token, wme)
         @tests.each do |test|
-          return false unless test.matches?( token, wme )
+          return false unless test.matches?(token, wme)
         end
         true
       end
 
-      def collect_assignments wme
+      def collect_assignments(wme)
         assignments = {}
         return assignments if assignment_pattern.nil?
-        if assignment_pattern.subject != :_
-          assignments[ assignment_pattern.subject ] = TokenAssignment.new(wme, :subject)
-        end
-        if assignment_pattern.predicate != :_
-          assignments[ assignment_pattern.predicate ] = TokenAssignment.new(wme, :predicate)
-        end
-        if assignment_pattern.object != :_
-          assignments[ assignment_pattern.object ] = TokenAssignment.new(wme, :object)
-        end
+
+        assignments[assignment_pattern.subject] = TokenAssignment.new(wme, :subject) if assignment_pattern.subject != :_
+        assignments[assignment_pattern.predicate] = TokenAssignment.new(wme, :predicate) if assignment_pattern.predicate != :_
+        assignments[assignment_pattern.object] = TokenAssignment.new(wme, :object) if assignment_pattern.object != :_
         assignments
       end
-
     end
   end
 end

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

@@ -5,49 +5,48 @@ module Wongi
 
       attr_accessor :partner
 
-      def initialize parent
-        super
-      end
-
-      def beta_activate token
+      def beta_activate(token)
         return if tokens.find { |t| t.parent == token }
+
         t = Token.new self, token, nil, {}
         t.overlay.add_token(t, self)
         partner.tokens.each do |ncc_token|
           next unless ncc_token.ancestors.find { |a| a.equal? token }
+
           t.ncc_results << ncc_token
           ncc_token.owner = t
         end
-        if t.ncc_results.empty?
-          children.each do |child|
-            child.beta_activate Token.new( child, t, nil, { } )
-          end
+        return unless t.ncc_results.empty?
+
+        children.each do |child|
+          child.beta_activate Token.new(child, t, nil, {})
         end
       end
 
-      def beta_deactivate token
+      def beta_deactivate(token)
         t = tokens.find { |tok| tok.parent == token }
         return unless t
+
         t.overlay.remove_token(t, self)
         t.deleted!
         partner.tokens.select { |ncc| ncc.owner == t }.each do |ncc_token|
           ncc_token.owner = nil
-          t.ncc_results.delete ncc_token
+          t.ncc_results.delete(ncc_token)
         end
         children.each do |beta|
-          beta.tokens.select { |token| token.parent == t }.each do |token|
-            beta.beta_deactivate token
+          beta.tokens.select { |child_token| child_token.parent == t }.each do |child_token|
+            beta.beta_deactivate(child_token)
           end
         end
       end
 
-      def ncc_activate token
+      def ncc_activate(token)
         children.each do |child|
-          child.beta_activate Token.new( child, token, nil, { } )
+          child.beta_activate Token.new(child, token, nil, {})
         end
       end
 
-      def ncc_deactivate token
+      def ncc_deactivate(token)
         children.each do |beta|
           beta.tokens.select { |t| t.parent == token }.each do |t|
             beta.beta_deactivate t
@@ -55,11 +54,9 @@ module Wongi
         end
       end
 
-      def refresh_child child
+      def refresh_child(child)
         tokens.each do |token|
-          if token.ncc_results.empty?
-            child.beta_activate Token.new( child, token, nil, { } )
-          end
+          child.beta_activate Token.new(child, token, nil, {}) if token.ncc_results.empty?
         end
       end
     end

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

@@ -3,35 +3,35 @@ module Wongi
     class NccPartner < BetaNode
       include TokenContainer
 
-      attr_accessor :ncc
-      attr_accessor :divergent
+      attr_accessor :ncc, :divergent
 
-      def beta_activate token
+      def beta_activate(token)
         t = Token.new self, token, nil, {}
-        owner = owner_for( t )
+        owner = owner_for(t)
         t.overlay.add_token(t, self)
-        if owner
-          owner.ncc_results << t
-          t.owner = owner
-          owner.node.ncc_deactivate owner
-        end
+        return unless owner
+
+        owner.ncc_results << t
+        t.owner = owner
+        owner.node.ncc_deactivate owner
       end
 
-      def beta_deactivate t
+      def beta_deactivate(t)
         token = tokens.find { |tok| tok.parent == t }
         return unless token
+
         token.overlay.remove_token(token, self)
-        if owner = token.owner
-          owner.ncc_results.delete token
-          if owner.ncc_results.empty?
-            ncc.ncc_activate owner
-          end
-        end
+
+        owner = token.owner
+        return unless owner
+
+        owner.ncc_results.delete token
+        ncc.ncc_activate owner if owner.ncc_results.empty?
       end
 
       private
 
-      def owner_for token
+      def owner_for(token)
         divergent_token = token.ancestors.find { |t| t.node == divergent }
         ncc.tokens.find { |t| t.ancestors.include? divergent_token }
       end

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

@@ -1,6 +1,5 @@
 module Wongi
   module Engine
-
     NegJoinResult = Struct.new :token, :wme do
       def unlink
         wme.neg_join_results.delete self
@@ -13,82 +12,83 @@ module Wongi
 
       attr_reader :alpha, :tests
 
-      def initialize parent, tests, alpha, unsafe
+      def initialize(parent, tests, alpha, unsafe)
         super(parent)
-        @tests, @alpha, @unsafe = tests, alpha, unsafe
+        @tests = tests
+        @alpha = alpha
+        @unsafe = unsafe
       end
 
-      def alpha_activate wme
+      def alpha_activate(wme)
         tokens.each do |token|
-          if matches?( token, wme ) && ( @unsafe || ! token.generated?( wme ) )# feedback loop protection
-            # order matters for proper invalidation
-            make_join_result(token, wme)
-            #token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
-            children.each do |child|
-              child.tokens.each do |t|
-                if t.parent == token
-                  child.beta_deactivate t
-                  #token.destroy
-                end
+          next unless matches?(token, wme) && (@unsafe || !token.generated?(wme)) # feedback loop protection
+
+          # order matters for proper invalidation
+          make_join_result(token, wme)
+          # token.delete_children #if token.neg_join_results.empty? # TODO why was this check here? it seems to break things
+          children.each do |child|
+            child.tokens.each do |t|
+              if t.parent == token
+                child.beta_deactivate t
+                # token.destroy
               end
             end
           end
         end
       end
 
-      def alpha_deactivate wme
+      def alpha_deactivate(wme)
         wme.neg_join_results.dup.each do |njr|
           tokens.each do |token|
             next unless token == njr.token
+
             njr.unlink
-            if token.neg_join_results.empty?
-              children.each do |child|
-                child.beta_activate Token.new( child, token, nil, {} )
-              end
+            next unless token.neg_join_results.empty?
+
+            children.each do |child|
+              child.beta_activate Token.new(child, token, nil, {})
             end
           end
         end
       end
 
-      def beta_activate token
+      def beta_activate(token)
         return if tokens.find { |et| et.duplicate? token }
+
         token.overlay.add_token(token, self)
         alpha.wmes.each do |wme|
-          if matches?( token, wme )
-            make_join_result(token, wme)
-          end
+          make_join_result(token, wme) if matches?(token, wme)
         end
-        if token.neg_join_results.empty?
-          children.each do |child|
-            child.beta_activate Token.new( child, token, nil, {} )
-          end
+        return unless token.neg_join_results.empty?
+
+        children.each do |child|
+          child.beta_activate Token.new(child, token, nil, {})
         end
       end
 
-      def beta_deactivate token
+      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
-        token.neg_join_results.each &:unlink
+        token.neg_join_results.each(&:unlink)
         children.each do |child|
           child.tokens.each do |t|
             if t.parent == token
               child.beta_deactivate t
-              #token.destroy
+              # token.destroy
             end
           end
         end
         token
       end
 
-      def refresh_child child
+      def refresh_child(child)
         tokens.each do |token|
-          if token.neg_join_results.empty?
-            child.beta_activate Token.new( child, token, nil, {} )
-          end
+          child.beta_activate Token.new(child, token, nil, {}) if token.neg_join_results.empty?
         end
         alpha.wmes.each do |wme|
           alpha_activate wme
@@ -97,15 +97,15 @@ module Wongi
 
       protected
 
-      def matches? token, wme
+      def matches?(token, wme)
         puts "matching #{wme} against #{token}" if debug?
         @tests.each do |test|
-          return false unless test.matches?( token, wme )
+          return false unless test.matches?(token, wme)
         end
         true
       end
 
-      def make_join_result token, wme
+      def make_join_result(token, wme)
         njr = NegJoinResult.new token, wme
         token.neg_join_results << njr
         wme.neg_join_results << njr

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

@@ -1,6 +1,5 @@
 module Wongi
   module Engine
-
     OptionalJoinResult = Struct.new :token, :wme do
       def unlink
         wme.opt_join_results.delete self
@@ -13,100 +12,99 @@ module Wongi
 
       attr_reader :alpha, :tests, :assignment_pattern
 
-      def initialize parent, alpha, tests, assignments
-        super( parent )
+      def initialize(parent, alpha, tests, assignments)
+        super(parent)
         @alpha = alpha
         @tests = tests
         @assignment_pattern = assignments
       end
 
-      def make_opt_result token, wme
+      def make_opt_result(token, wme)
         jr = OptionalJoinResult.new token, wme
         token.opt_join_results << jr
         wme.opt_join_results << jr
       end
 
-      def alpha_activate wme
-        assignments = collect_assignments( wme )
+      def alpha_activate(wme)
+        assignments = collect_assignments(wme)
         tokens.each do |token|
-          if matches? token, wme
-            children.each do |child|
-              if token.optional?
-                token.no_optional!
-                child.tokens.each do |ct|
-                  child.beta_deactivate(ct) if ct.parent == token
-                end
+          next unless matches? token, wme
+
+          children.each do |child|
+            if token.optional?
+              token.no_optional!
+              child.tokens.each do |ct|
+                child.beta_deactivate(ct) if ct.parent == token
               end
-              child.beta_activate Token.new( child, token, wme, assignments )
             end
-            make_opt_result token, wme
+            child.beta_activate Token.new(child, token, wme, assignments)
           end
+          make_opt_result token, wme
         end
       end
 
-      def alpha_deactivate wme
+      def alpha_deactivate(wme)
         wme.opt_join_results.dup.each do |ojr|
           tokens.each do |token|
             next unless token == ojr.token
+
             ojr.unlink
-            if token.opt_join_results.empty?
-              children.each do |child|
-                child.tokens.each do |ct|
-                  child.beta_deactivate(ct) if ct.parent == token
-                end
-                token.optional!
-                child.beta_activate Token.new( child, token, nil, { } )
+            next unless token.opt_join_results.empty?
+
+            children.each do |child|
+              child.tokens.each do |ct|
+                child.beta_deactivate(ct) if ct.parent == token
               end
+              token.optional!
+              child.beta_activate Token.new(child, token, nil, {})
             end
           end
         end
       end
 
-      def beta_activate t
+      def beta_activate(t)
         return if tokens.find { |token| token.parent == t }
-        token = Token.new( self, t, nil, { } )
+
+        token = Token.new(self, t, nil, {})
         token.overlay.add_token(token, self)
         match = false
         alpha.wmes.each do |wme|
           assignments = collect_assignments(wme)
-          if matches? token, wme
-            match = true
-            children.each do |child|
-              child.beta_activate Token.new( child, token, wme, assignments )
-            end
-            make_opt_result token, wme
-          end
-        end
-        unless match
-          token.optional!
+          next unless matches? token, wme
+
+          match = true
           children.each do |child|
-            child.beta_activate Token.new( child, token, nil, { } )
+            child.beta_activate Token.new(child, token, wme, assignments)
           end
+          make_opt_result token, wme
+        end
+        return if match
+
+        token.optional!
+        children.each do |child|
+          child.beta_activate Token.new(child, token, nil, {})
         end
       end
 
-      def beta_deactivate t
-        token = tokens.find { |token| token.parent == t }
+      def beta_deactivate(t)
+        token = tokens.find { |own_token| own_token.parent == t }
         return unless token
+
         token.overlay.remove_token(token, self)
         token.deleted!
-        if token.parent
-          token.parent.children.delete token
-        end
-        token.opt_join_results.each &:unlink
+        token.parent.children.delete token if token.parent
+        token.opt_join_results.each(&:unlink)
         children.each do |child|
-          child.tokens.each do |t|
-            if t.parent == token
-              child.beta_deactivate t
-            end
+          child.tokens.each do |child_token|
+            child.beta_deactivate(child_token) if child_token.parent == token
           end
         end
         token
       end
 
-      def refresh_child child
+      def refresh_child(child)
         tmp = children
-        self.children = [ child ]
+        self.children = [child]
         refresh # do the beta part
         alpha.wmes.each do |wme|
           alpha_activate wme
@@ -116,25 +114,20 @@ module Wongi
 
       private
 
-      def matches? token, wme
+      def matches?(token, wme)
         @tests.each do |test|
-          return false unless test.matches?( token, wme )
+          return false unless test.matches?(token, wme)
         end
         true
       end
 
-      def collect_assignments wme
+      def collect_assignments(wme)
         assignments = {}
         return assignments if assignment_pattern.nil?
-        if assignment_pattern.subject != :_
-          assignments[ assignment_pattern.subject ] = TokenAssignment.new(wme, :subject)
-        end
-        if assignment_pattern.predicate != :_
-          assignments[ assignment_pattern.predicate ] = TokenAssignment.new(wme, :predicate)
-        end
-        if assignment_pattern.object != :_
-          assignments[ assignment_pattern.object ] = TokenAssignment.new(wme, :object)
-        end
+
+        assignments[assignment_pattern.subject] = TokenAssignment.new(wme, :subject) if assignment_pattern.subject != :_
+        assignments[assignment_pattern.predicate] = TokenAssignment.new(wme, :predicate) if assignment_pattern.predicate != :_
+        assignments[assignment_pattern.object] = TokenAssignment.new(wme, :object) if assignment_pattern.object != :_
         assignments
       end
     end