wongi-engine 0.3.6 → 0.3.7

data/lib/wongi-engine/network.rb

@@ -3,18 +3,14 @@ require 'wongi-engine/network/debug'
 
 module Wongi::Engine
   class Network
-
-    attr_reader :alpha_top, :beta_top
-    attr_reader :queries, :results
-    attr_reader :productions
-    attr_reader :overlays
+    attr_reader :alpha_top, :beta_top, :queries, :results, :productions
 
     include NetworkParts::Collectable
 
     protected
+
     attr_accessor :alpha_hash
-    attr_writer :alpha_top, :beta_top
-    attr_writer :queries, :results
+    attr_writer :alpha_top, :beta_top, :queries, :results
 
     public
 
@@ -23,43 +19,43 @@ module Wongi::Engine
     end
 
     def rdf!
-      if ! defined? Wongi::RDF::DocumentSupport
+      unless defined? Wongi::RDF::DocumentSupport
         begin
           require 'wongi-rdf'
-        rescue LoadError => e
+        rescue LoadError
           raise "'wongi-rdf' is required for RDF support"
         end
       end
 
       extend Wongi::RDF::DocumentSupport
+
       class << self
         def statements
           alpha_top.wmes
         end
       end
 
-      @namespaces = { }
+      @namespaces = {}
       @blank_counter = 1
       @ns_counter = 0
-      @used_blanks = { }
+      @used_blanks = {}
     end
 
     def initialize
       @timeline = []
-      self.alpha_top = AlphaMemory.new( Template.new( :_, :_, :_ ), self )
+      self.alpha_top = AlphaMemory.new(Template.new(:_, :_, :_), self)
       self.alpha_hash = { alpha_top.template.hash => alpha_top }
       self.beta_top = BetaMemory.new(nil)
-      self.beta_top.rete = self
-      self.beta_top.seed
+      beta_top.rete = self
+      beta_top.seed
       self.queries = {}
       self.results = {}
       @revns = {}
 
-      @productions = { }
+      @productions = {}
 
       @collectors = {}
       @collectors[:error] = []
-
     end
 
     def dump
@@ -118,46 +114,42 @@ module Wongi::Engine
     end
 
     # @private
-    def real_assert( wme )
-      unless wme.rete == self
-        wme = wme.import_into self
-      end
+    def real_assert(wme)
+      wme = wme.import_into self unless wme.rete == self
 
-      source = best_alpha(wme)
-      if existing = find(wme.subject, wme.predicate, wme.object)
+      # source = best_alpha(wme)
+      if (existing = find(wme.subject, wme.predicate, wme.object))
         existing.manual! if wme.manual?
         return
       end
 
-      alphas_for( wme ).each { |a| a.activate wme }
+      alphas_for(wme).each { |a| a.activate wme }
 
       wme
     end
 
     # @private
-    def real_retract wme, options
+    def real_retract(wme, options)
       real = find(wme.subject, wme.predicate, wme.object)
       return if real.nil?
+
       if real.generated? # still some generator tokens left
-        if real.manual?
-          real.manual = false
-        else
-          raise Error, "cannot retract automatic facts"
-        end
-      else
-        if options[:automatic] && real.manual? # auto-retracting a fact that has been added manually
-          return
-        end
+        raise Error, "cannot retract automatic facts" unless real.manual?
+
+        real.manual = false
+      elsif options[:automatic] && real.manual?
+        return
       end
 
-      alphas_for( real ).each { |a| a.deactivate real }
+      alphas_for(real).each { |a| a.deactivate real }
     end
 
     def wmes
       alpha_top.wmes
     end
-    alias_method :statements, :wmes
-    alias_method :facts, :wmes
+
+    alias statements wmes
+    alias facts wmes
 
     def in_snapshot?
       @in_snapshot
@@ -166,128 +158,127 @@ module Wongi::Engine
     def snapshot!
       @timeline.each_with_index do |slice, index|
         source = if index == @timeline.size - 1
-          alpha_hash
-        else
-          @timeline[index+1]
-        end
+                   alpha_hash
+                 else
+                   @timeline[index + 1]
+                 end
         # puts "source = #{source}"
         wmes = {}
-        slice.each { |key, alpha| wmes[key] = alpha.wmes }
         slice.each do |key, alpha|
+          wmes[key] = alpha.wmes
           in_snapshot {
-            wmes[key].dup.each { |wme| wme.destroy }
+            wmes[key].dup.each(&:destroy)
           }
           alpha.snapshot! source[key]
         end
       end
     end
 
-    def rule name = nil, &block
-      r = DSL::Rule.new( name || generate_rule_name )
-      r.instance_eval &block
+    def rule(name = nil, &block)
+      r = DSL::Rule.new(name || generate_rule_name)
+      r.instance_eval(&block)
       self << r
     end
 
-    def query name, &block
+    def query(name, &block)
       q = DSL::Query.new name
-      q.instance_eval &block
+      q.instance_eval(&block)
       self << q
     end
 
-    def << something
-      if something.respond_to?( :install )
-        something.install( self )
+    def <<(something)
+      if something.respond_to?(:install)
+        something.install(self)
       else
         case something
         when Array
-          assert WME.new( *something ).tap { |wme| wme.overlay = default_overlay }
+          assert(WME.new(*something).tap { |wme| wme.overlay = default_overlay })
         when WME
           assert something
-        # when Wongi::RDF::Statement
-        #   assert WME.new( something.subject, something.predicate, something.object, self )
-        #when Wongi::RDF::Document
+          # when Wongi::RDF::Statement
+          #   assert WME.new( something.subject, something.predicate, something.object, self )
+          # when Wongi::RDF::Document
           #  something.statements.each do |st|
           #    assert WME.new( st.subject, st.predicate, st.object, self )
           #  end
         when Network
-          something.wmes.each { |wme| assert( wme ) }
+          something.wmes.each { |wme| assert(wme) }
         else
           raise Error, "I don't know how to accept a #{something.class}"
         end
       end
     end
 
-    def install_rule( rule )
+    def install_rule(rule)
       derived = rule.import_into self
       production = build_production beta_top, derived.conditions, [], derived.actions, false
-      if rule.name
-        productions[ rule.name ] = production
-      end
+      productions[rule.name] = production if rule.name
       production
     end
 
-    def install_query( query )
+    def install_query(query)
       derived = query.import_into self
       prepare_query derived.name, derived.conditions, derived.parameters, derived.actions
     end
 
-    def compile_alpha condition
+    def compile_alpha(condition)
       template = Template.new :_, :_, :_
       time = condition.time
 
-      template.subject = condition.subject unless Template.variable?( condition.subject )
-      template.predicate = condition.predicate unless Template.variable?( condition.predicate )
-      template.object = condition.object unless Template.variable?( condition.object )
+      template.subject = condition.subject unless Template.variable?(condition.subject)
+      template.predicate = condition.predicate unless Template.variable?(condition.predicate)
+      template.object = condition.object unless Template.variable?(condition.object)
 
       hash = template.hash
       # puts "COMPILED CONDITION #{condition} WITH KEY #{key}"
-      if time == 0
-        return self.alpha_hash[ hash ] if self.alpha_hash.has_key?( hash )
-      else
-        return @timeline[time+1][ hash ] if @timeline[time+1] && @timeline[time+1].has_key?( hash )
+      if time.zero?
+        return alpha_hash[hash] if alpha_hash.key?(hash)
+      elsif @timeline[time + 1] && @timeline[time + 1].key?(hash)
+        return @timeline[time + 1][hash]
       end
 
-      alpha = AlphaMemory.new( template, self )
+      alpha = AlphaMemory.new(template, self)
 
-      if time == 0
-        self.alpha_hash[ hash ] = alpha
+      if time.zero?
+        alpha_hash[hash] = alpha
         initial_fill alpha
       else
-        if @timeline[time+1].nil?
+        if @timeline[time + 1].nil?
           # => ensure lineage from 0 to time
           compile_alpha condition.class.new(condition.subject, condition.predicate, condition.object, time: time + 1)
-          @timeline.unshift Hash.new
+          @timeline.unshift({})
         end
-        @timeline[time+1][ hash ] = alpha
+        @timeline[time + 1][hash] = alpha
       end
       alpha
     end
 
-    def cache s, p, o
+    def cache(s, p, o)
       compile_alpha Template.new(s, p, o)
     end
 
     # TODO: pick an alpha with fewer candidates to go through
-    def initial_fill alpha
+    def initial_fill(alpha)
       alpha_top.wmes.each do |wme|
         alpha.activate wme if wme =~ alpha.template
       end
     end
 
-    def remove_production pnode
+    def remove_production(pnode)
       delete_node_with_ancestors pnode
     end
 
-    def prepare_query name, conditions, parameters, actions = []
-      query = self.queries[ name ] = BetaMemory.new( nil )
+    def prepare_query(name, conditions, parameters, actions = [])
+      query = queries[name] = BetaMemory.new(nil)
       query.rete = self
-      query.seed(Hash[parameters.map{ |param| [param, nil]}])
-      self.results[ name ] = build_production query, conditions, parameters, actions, true
+      query.seed(parameters.to_h { |param| [param, nil] })
+      results[name] = build_production query, conditions, parameters, actions, true
     end
 
-    def execute name, valuations
-      beta = self.queries[name]
+    def execute(name, valuations)
+      beta = queries[name]
       raise Error, "Undefined query #{name}; known queries are #{queries.keys}" unless beta
+
       beta.subst valuations
     end
 
@@ -295,19 +286,19 @@ module Wongi::Engine
       "<Rete>"
     end
 
-    def exists? wme
+    def exists?(wme)
       find(wme.subject, wme.predicate, wme.object)
     end
 
-    def each *args, &block
+    def each(*args, &block)
       template = case args.length
-      when 0
-        Template.new(:_, :_, :_)
-      when 3
-        Template.new(*args)
-      else
-        raise Error, "Network#each expect a template or nothing at all"
-      end
+                 when 0
+                   Template.new(:_, :_, :_)
+                 when 3
+                   Template.new(*args)
+                 else
+                   raise Error, "Network#each expect a template or nothing at all"
+                 end
       source = best_alpha(template)
       matching = current_overlay.wmes(source).select { |wme| wme =~ template }
       if block_given?
@@ -317,17 +308,15 @@ module Wongi::Engine
       end
     end
 
-    def select s, p, o
+    def select(s, p, o)
       template = Template.new(s, p, o)
       source = best_alpha(template)
       matching = current_overlay.wmes(source).select { |wme| wme =~ template }
-      if block_given?
-        matching.each { |st| yield st.subject, st.predicate, st.object }
-      end
+      matching.each { |st| yield st.subject, st.predicate, st.object } if block_given?
       matching
     end
 
-    def find s, p, o
+    def find(s, p, o)
       template = Template.new(s, p, o)
       source = best_alpha(template)
       # puts "looking for #{template} among #{source.wmes.size} triples of #{source.template}"
@@ -336,7 +325,6 @@ module Wongi::Engine
 
     protected
 
-
     def in_snapshot
       @in_snapshot = true
       yield
@@ -348,31 +336,33 @@ module Wongi::Engine
       "rule_#{productions.length}"
     end
 
-    def alphas_for wme
-      s, p, o = wme.subject, wme.predicate, wme.object
+    def alphas_for(wme)
+      s = wme.subject
+      p = wme.predicate
+      o = wme.object
       [
-        lookup( s,  p,  o),
-        lookup( s,  p, :_),
-        lookup( s, :_,  o),
-        lookup(:_,  p,  o),
-        lookup( s, :_, :_),
-        lookup(:_,  p, :_),
-        lookup(:_, :_,  o),
+        lookup(s, p, o),
+        lookup(s, p, :_),
+        lookup(s, :_, o),
+        lookup(:_, p, o),
+        lookup(s, :_, :_),
+        lookup(:_, p, :_),
+        lookup(:_, :_, o),
         lookup(:_, :_, :_),
       ].compact!.tap(&:uniq!)
     end
 
-    def lookup s, p, o
+    def lookup(s, p, o)
       key = Template.hash_for(s, p, o)
       # puts "Lookup for #{key}"
-      self.alpha_hash[ key ]
+      alpha_hash[key]
     end
 
-    def alpha_activate alpha, wme
+    def alpha_activate(alpha, wme)
       alpha.activate(wme)
     end
 
-    def best_alpha template
+    def best_alpha(template)
       alpha_hash.inject(nil) do |best, (_, alpha)|
         if template =~ alpha.template && (best.nil? || alpha.size < best.size)
           alpha
@@ -382,7 +372,7 @@ module Wongi::Engine
       end
     end
 
-    def build_production root, conditions, parameters, actions, alpha_deaf
+    def build_production(root, conditions, parameters, actions, alpha_deaf)
       compiler = Compiler.new(self, root, conditions, parameters, alpha_deaf)
       ProductionNode.new(compiler.compile, actions).tap do |production|
         production.compilation_context = compiler
@@ -390,27 +380,18 @@ module Wongi::Engine
       end
     end
 
-    def delete_node_with_ancestors node
+    def delete_node_with_ancestors(node)
+      delete_node_with_ancestors node.partner if node.is_a?(NccNode)
 
-      if node.kind_of?( NccNode )
-        delete_node_with_ancestors node.partner
-      end
+      # the root node should not be deleted
+      return unless node.parent
 
-      if [BetaMemory, NegNode, NccNode, NccPartner].any? { | klass| node.kind_of? klass }
-        while node.tokens.first
-          node.tokens.first.delete
-        end
-      end
-
-      if node.parent
-        node.parent.children.delete node
-        if node.parent.children.empty?
-          delete_node_with_ancestors(node.parent)
-        end
+      if [BetaMemory, NegNode, NccNode, NccPartner].any? { |klass| node.is_a? klass }
+        node.tokens.first.destroy while node.tokens.first
       end
 
+      node.parent.children.delete node
+      delete_node_with_ancestors(node.parent) if node.parent.children.empty?
     end
-
   end
-
 end

data/lib/wongi-engine/ruleset.rb

@@ -1,17 +1,17 @@
 module Wongi
   module Engine
     class Ruleset
-
       class << self
+        def [](name)
+          raise Error, "undefined ruleset #{name}" unless rulesets.key?(name)
 
-        def [] name
-          raise Error, "undefined ruleset #{name}" unless rulesets.has_key?( name )
-          rulesets[ name ]
+          rulesets[name]
         end
 
-        def register name, ruleset
-          raise Error, "ruleset #{name} already exists" if rulesets.has_key?( name )
-          rulesets[ name ] = ruleset
+        def register(name, ruleset)
+          raise Error, "ruleset #{name} already exists" if rulesets.key?(name)
+
+          rulesets[name] = ruleset
         end
 
         def rulesets
@@ -19,31 +19,30 @@ module Wongi
         end
 
         def reset
-          @rulesets = { }
+          @rulesets = {}
         end
-
       end
 
-      def initialize name = nil
+      def initialize(name = nil)
         @rules = []
-        self.name( name ) if name
+        self.name(name) if name
       end
 
       def inspect
         "<Ruleset #{name}>"
       end
 
-      def install rete
+      def install(rete)
         # puts "Installing ruleset #{name}"
         @rules.each { |rule| rete << rule }
       rescue StandardError => e
-        e1 = Error.new "error installing ruleset '#{name||'<unnamed>'}': #{e}"
+        e1 = Error.new "error installing ruleset '#{name || '<unnamed>'}': #{e}"
         e1.set_backtrace e.backtrace
         raise e1
       end
 
-      def name name = nil
-        if name && ! @name
+      def name(name = nil)
+        if name && !@name
           self.class.register name, self
           @name = name
         end
@@ -55,20 +54,19 @@ module Wongi
       #      @uri
       #    end
 
-      def rule name, &definition
+      def rule(name, &definition)
         r = DSL::Rule.new name
-        r.instance_eval &definition
+        r.instance_eval(&definition)
         @rules << r
         r
       end
 
-      def query name, &definition
+      def query(name, &definition)
         r = DSL::Query.new name
-        r.instance_eval &definition
+        r.instance_eval(&definition)
         @rules << r
         r
       end
-
     end
   end
 end

data/lib/wongi-engine/template.rb

@@ -1,9 +1,8 @@
 module Wongi::Engine
-
-  Template = Struct.new( :subject, :predicate, :object ) do
-
-    def self.variable? thing
+  Template = Struct.new(:subject, :predicate, :object) do
+    def self.variable?(thing)
       return false unless thing.is_a?(Symbol)
+
       thing[0] >= 'A' && thing[0] <= 'Z'
     end
 
@@ -15,9 +14,9 @@ module Wongi::Engine
 
     def variables
       [].tap do |a|
-        a << subject if Template.variable?( subject )
-        a << predicate if Template.variable?( predicate )
-        a << object if Template.variable?( object )
+        a << subject if Template.variable?(subject)
+        a << predicate if Template.variable?(predicate)
+        a << object if Template.variable?(object)
       end
     end
 
@@ -25,20 +24,20 @@ module Wongi::Engine
       @hash ||= [subject.hash, predicate.hash, object.hash].hash
     end
 
-    def self.hash_for *args
-      args.map( &:hash ).hash
+    def self.hash_for(*args)
+      args.map(&:hash).hash
     end
 
-    def == other
+    def ==(other)
       other.is_a?(Template) && subject == other.subject && predicate == other.predicate && object == other.object
     end
 
-    def =~ template
+    def =~(template)
       case template
       when Template
-        ( template.subject == :_ || template.subject == subject ) &&
-        ( template.predicate == :_ || template.predicate == predicate ) &&
-        ( template.object == :_ || template.object == object )
+        (template.subject == :_ || template.subject == subject) &&
+          (template.predicate == :_ || template.predicate == predicate) &&
+          (template.object == :_ || template.object == object)
       else
         raise Error, "templates can only match other templates"
       end
@@ -54,25 +53,27 @@ module Wongi::Engine
 
     def resolve!(token)
       s = if Template.variable?(subject)
-        raise DefinitionError, "unbound variable #{subject} in token #{token}" unless token.has_var?(subject)
-        token[subject]
-      else
-        subject
-      end
+            raise DefinitionError, "unbound variable #{subject} in token #{token}" unless token.has_var?(subject)
+
+            token[subject]
+          else
+            subject
+          end
       p = if Template.variable?(predicate)
-        raise DefinitionError, "unbound variable #{predicate} in token #{token}" unless token.has_var?(predicate)
-        token[predicate]
-      else
-        predicate
-      end
+            raise DefinitionError, "unbound variable #{predicate} in token #{token}" unless token.has_var?(predicate)
+
+            token[predicate]
+          else
+            predicate
+          end
       o = if Template.variable?(object)
-        raise DefinitionError, "unbound variable #{object} in token #{token}" unless token.has_var?(object)
-        token[object]
-      else
-        object
-      end
+            raise DefinitionError, "unbound variable #{object} in token #{token}" unless token.has_var?(object)
+
+            token[object]
+          else
+            object
+          end
       [s, p, o]
     end
-
   end
 end