wongi-engine 0.1.4 → 0.2.0

data/lib/wongi-engine/network.rb

@@ -7,6 +7,7 @@ module Wongi::Engine
     attr_reader :alpha_top, :beta_top
     attr_reader :queries, :results
     attr_reader :productions
+    attr_reader :overlays
 
     include NetworkParts::Collectable
 
@@ -46,7 +47,7 @@ module Wongi::Engine
     def initialize
       @timeline = []
       self.alpha_top = AlphaMemory.new( Template.new( :_, :_, :_ ), self )
-      self.alpha_hash = { Template.hash_for( :_, :_, :_ ) => self.alpha_top }
+      self.alpha_hash = { alpha_top.template.hash => alpha_top }
       self.beta_top = BetaMemory.new(nil)
       self.beta_top.rete = self
       self.beta_top.seed
@@ -54,7 +55,6 @@ module Wongi::Engine
       self.results = {}
       @cache = {}
       @revns = {}
-      @contexts = {}
 
       @productions = { }
 
@@ -67,69 +67,58 @@ module Wongi::Engine
       beta_top.dump
     end
 
+    def with_overlay(&block)
+      default_overlay.with_child(&block)
+    end
+
     def alphas
       alpha_hash.values
     end
 
-    def import thing
-      case thing
-      when String, Numeric, TrueClass, FalseClass, NilClass, Wongi::RDF::Node
-        thing
-      when Symbol
-        thing
-      else
-        thing
-      end
+    # def import thing
+    #   case thing
+    #   when String, Numeric, TrueClass, FalseClass, NilClass, Wongi::RDF::Node
+    #     thing
+    #   when Symbol
+    #     thing
+    #   else
+    #     thing
+    #   end
+    # end
+
+    def default_overlay
+      @default_overlay ||= DataOverlay.new(self)
     end
 
-    def assert wme
-      @next_cascade ||= []
-      @next_cascade << [:assert, wme]
-      if @current_cascade.nil?
-        @current_cascade = @next_cascade
-        @next_cascade = nil
-        process_cascade
-      end
+    # @private
+    def add_overlay(o)
+      overlays << o
     end
 
-    def retract wme, options = { }
-      @next_cascade ||= []
-      @next_cascade << [:retract, wme, options]
-      if @current_cascade.nil?
-        @current_cascade = @next_cascade
-        @next_cascade = nil
-        process_cascade
-      end
+    # @private
+    def remove_overlay(o)
+      overlays.delete(o) unless o == default_overlay
     end
 
-    def process_cascade
-      iterations = 0
-      while @current_cascade
-        @current_cascade.each do |(operation, wme, options)|
-          case operation
-          when :assert
-            real_assert wme
-          when :retract
-            real_retract wme, options
-          end
-        end
-        @current_cascade = @next_cascade
-        @next_cascade = nil
-        iterations += 1
-      end
+    # @private
+    def overlays
+      @overlays ||= []
+    end
+
+    def assert(wme)
+      default_overlay.assert(wme)
     end
 
-    def real_assert wme
+    def retract(wme, options = {})
+      default_overlay.retract(wme, options)
+    end
 
+    # @private
+    def real_assert( wme )
       unless wme.rete == self
         wme = wme.import_into self
       end
 
-      if @current_context
-        @current_context.asserted_wmes << wme
-        wme.context = @current_context
-      end
-
       if existing = @cache[wme]
         existing.manual! if wme.manual?
         return
@@ -143,6 +132,28 @@ module Wongi::Engine
       wme
     end
 
+    # @private
+    def real_retract wme, options
+      real = @cache[wme]
+
+      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
+      end
+
+      @cache.delete(real)
+
+      alphas_for( real ).each { |a| a.deactivate real }
+    end
+
     def wmes
       alpha_top.wmes
     end
@@ -173,82 +184,52 @@ module Wongi::Engine
     end
 
     def rule name = nil, &block
-      r = ProductionRule.new( name || generate_rule_name )
+      r = DSL::Rule.new( name || generate_rule_name )
       r.instance_eval &block
       self << r
     end
 
     def query name, &block
-      q = Query.new name
+      q = DSL::Query.new name
       q.instance_eval &block
       self << q
     end
 
     def << something
-      case something
-      when Array
-        if something.length == 3
+      if something.respond_to?( :install )
+        something.install( self )
+      else
+        case something
+        when Array
           assert WME.new( *something )
+        when WME
+          assert something
+        # 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 ) }
         else
-          raise "Arrays must have 3 elements"
-        end
-      when ProductionRule
-        derived = something.import_into self
-        production = add_production derived.conditions, derived.actions
-        if something.name
-          productions[ something.name ] = production
+          raise Error, "I don't know how to accept a #{something.class}"
         end
-        production
-      when Query
-        derived = something.import_into self
-        prepare_query derived.name, derived.conditions, derived.parameters, derived.actions
-      when Ruleset
-        something.install self
-      when WME
-        assert something
-      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.each do |st|
-          assert st.import_into( self )
-        end
-      else
-        raise "I don't know how to accept a #{something.class}"
       end
     end
 
-    def real_retract wme, options
-
-      if wme.is_a? Array
-        return real_retract( WME.new(*wme), options )
-      end
-
-      real = @cache[wme]
-
-      return if real.nil?
-      if real.generated? # still some generator tokens left
-        if real.manual?
-          real.manual = false
-        else
-          raise "cannot retract automatic facts"
-        end
-      else
-        if options[:automatic] && real.manual? # auto-retracting a fact that has been added manually
-          return
-        end
-      end
-
-      if @current_context
-        @current_context.retracted_wmes << wme
+    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
+      production
+    end
 
-      @cache.delete(real)
-
-      alphas_for( real ).each { |a| a.deactivate real }
+    def install_query( query )
+      derived = query.import_into self
+      prepare_query derived.name, derived.conditions, derived.parameters, derived.actions
     end
 
     def compile_alpha condition
@@ -284,23 +265,16 @@ module Wongi::Engine
     end
 
     def cache s, p, o
-      compile_alpha Template.new(s, p, o).import_into( self )
+      compile_alpha Template.new(s, p, o)
     end
 
+    # TODO: pick an alpha with fewer candidates to go through
     def initial_fill alpha
-      tpl = alpha.template
-      source = more_generic_alpha(tpl)
-      # puts "more efficient by #{alpha_top.wmes.size - source.wmes.size}" unless source ==
-      # alpha_top
-      source.wmes.each do |wme|
-        alpha.activate wme if wme =~ tpl
+      alpha_top.wmes.each do |wme|
+        alpha.activate wme if wme =~ alpha.template
       end
     end
 
-    def add_production conditions, actions = []
-      real_add_production self.beta_top, conditions, [], actions, false
-    end
-
     def remove_production pnode
       delete_node_with_ancestors pnode
     end
@@ -308,15 +282,13 @@ module Wongi::Engine
     def prepare_query name, conditions, parameters, actions = []
       query = self.queries[ name ] = BetaMemory.new( nil )
       query.rete = self
-      transformed = {}
-      parameters.each { |param| transformed[param] = nil }
-      query.seed transformed
-      self.results[ name ] = real_add_production query, conditions, parameters, actions, true
+      query.seed(Hash[parameters.map{ |param| [param, nil]}])
+      self.results[ name ] = build_production query, conditions, parameters, actions, true
     end
 
     def execute name, valuations
       beta = self.queries[name]
-      raise "Undefined query #{name}; known queries are #{queries.keys}" unless beta
+      raise Error, "Undefined query #{name}; known queries are #{queries.keys}" unless beta
       beta.subst valuations
     end
 
@@ -324,25 +296,6 @@ module Wongi::Engine
       "<Rete>"
     end
 
-    def context= name
-      if name && !@contexts.has_key?(name)
-        @current_context = (@contexts[name] ||= ModelContext.new name)
-      end
-    end
-
-    # TODO: contexts are probably broken with the new improved handling of manual & generated
-    def retract_context name
-      return unless @contexts.has_key?(name)
-
-      if @current_context && @current_context.name == name
-        @current_context = nil
-      end
-      ctx = @contexts[name]
-      ctx.asserted_wmes.select { |wme| wme.generating_tokens.empty?  }.each { |wme| retract(wme, true) }
-      ctx.retracted_wmes.each { |wme| assert(wme) }
-      @contexts.delete name
-    end
-
     def exists? wme
       @cache[ wme ]
     end
@@ -350,7 +303,7 @@ module Wongi::Engine
     def each *args
       return unless block_given?
       unless args.length == 0 || args.length == 3
-        raise "Document#each expects a pattern or nothing at all"
+        raise Error, "Network#each expects a pattern or nothing at all"
       end
       s, p, o = if args.empty?
         [:_, :_, :_]
@@ -365,7 +318,7 @@ module Wongi::Engine
     end
 
     def select s, p, o
-      template = Template.new(s, p, o).import_into self
+      template = Template.new(s, p, o)
       matching = alpha_top.wmes.select { |wme| wme =~ template }
       if block_given?
         matching.each { |st| yield st.subject, st.predicate, st.object }
@@ -374,7 +327,7 @@ module Wongi::Engine
     end
 
     def find s, p, o
-      template = Template.new(s, p, o).import_into self
+      template = Template.new(s, p, o)
       source = best_alpha(template)
       # puts "looking for #{template} among #{source.wmes.size} triples of #{source.template}"
       source.wmes.detect { |wme| wme =~ template }
@@ -382,6 +335,7 @@ module Wongi::Engine
 
     protected
 
+
     def in_snapshot
       @in_snapshot = true
       yield
@@ -404,7 +358,7 @@ module Wongi::Engine
         lookup(:_,  p, :_),
         lookup(:_, :_,  o),
         lookup(:_, :_, :_),
-      ].compact.uniq
+      ].compact!.tap(&:uniq!)
     end
 
     def lookup s, p, o
@@ -414,52 +368,25 @@ module Wongi::Engine
     end
 
     def alpha_activate alpha, wme
-      alpha.activate(wme) if alpha
-    end
-
-    def more_generic_alpha template
-      return alpha_top    # OPTIMISE => temporary; may use later or not use at all
-      return alpha_top if template.root?
-      more_generic_templates(template).reduce alpha_top do |best, template|
-        alpha = alpha_hash[template.hash]
-        if alpha && alpha.wmes.size < best.wmes.size
-          alpha
-        else
-          best
-        end
-      end
-    end
-
-    def more_generic_templates template
-      set = []
-      set << template.with_subject( :_ ) unless template.subject == :_
-      set << template.with_predicate( :_ ) unless template.predicate == :_
-      set << template.with_object( :_ ) unless template.object == :_
-      set.select { |item| not item.root? }
+      alpha.activate(wme)
     end
 
     def best_alpha template
-      candidates = alpha_hash.values.select do |alpha|
-        template =~ alpha.template
-      end
-      result = candidates.inject do |best, alpha|
-        if best.nil?
-          alpha
-        elsif alpha.wmes.to_a.length < best.wmes.to_a.length
+      alpha_hash.inject(nil) do |best, (_, alpha)|
+        if template =~ alpha.template && (best.nil? || alpha.size < best.size)
           alpha
         else
           best
         end
       end
-      result
     end
 
-    def real_add_production root, conditions, parameters, actions, alpha_deaf
-      beta = root.network conditions, [], parameters, alpha_deaf
-
-      production = ProductionNode.new( beta, actions )
-      production.refresh
-      production
+    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
+        production.refresh
+      end
     end
 
     def delete_node_with_ancestors node

data/lib/wongi-engine/ruleset.rb

@@ -5,12 +5,12 @@ module Wongi
       class << self
 
         def [] name
-          raise "undefined ruleset #{name}" unless rulesets.has_key?( name )
+          raise Error, "undefined ruleset #{name}" unless rulesets.has_key?( name )
           rulesets[ name ]
         end
 
         def register name, ruleset
-          raise "ruleset #{name} already exists" if rulesets.has_key?( name )
+          raise Error, "ruleset #{name} already exists" if rulesets.has_key?( name )
           rulesets[ name ] = ruleset
         end
 
@@ -36,8 +36,8 @@ module Wongi
       def install rete
         # puts "Installing ruleset #{name}"
         @rules.each { |rule| rete << rule }
-      rescue Exception => e
-        e1 = Exception.new "error installing ruleset '#{name||'<unnamed>'}': #{e}"
+      rescue StandardError => e
+        e1 = Error.new "error installing ruleset '#{name||'<unnamed>'}': #{e}"
         e1.set_backtrace e.backtrace
         raise e1
       end
@@ -56,14 +56,14 @@ module Wongi
       #    end
 
       def rule name, &definition
-        r = ProductionRule.new name
+        r = DSL::Rule.new name
         r.instance_eval &definition
         @rules << r
         r
       end
 
       def query name, &definition
-        r = Query.new name
+        r = DSL::Query.new name
         r.instance_eval &definition
         @rules << r
         r

data/lib/wongi-engine/template.rb

@@ -1,60 +1,36 @@
 module Wongi::Engine
 
-  class Template < Struct.new( :subject, :predicate, :object, :time )
-
-    include CoreExt
-
-    attr_reader :unsafe
-    attr_predicate debug: false
+  Template = Struct.new( :subject, :predicate, :object ) do
 
     def self.variable? thing
-      Symbol === thing && thing =~ /^[A-Z]/
-    end
-
-    def initialize s, p, o, options = { }
-      time = options[:time] || 0
-      unsafe = options[:unsafe] || false
-      debug! if options[:debug]
-      raise "Cannot work with continuous time" unless time.integer?
-      raise "Cannot look into the future" if time > 0
-      super( s, p, o, time )
-      @filters = []
-      @unsafe = unsafe
+      return false unless thing.is_a?(Symbol)
+      thing[0] >= 'A' && thing[0] <= 'Z'
     end
 
-    def import_into r
-      copy = self.class.new r.import( subject ), r.import( predicate ), r.import( object ), time: time, unsafe: unsafe, debug: debug?
-      @filters.each { |f| copy.filters << f }
-      copy
-    end
+    # TODO: reintroduce Network#import when bringing back RDF support
 
     def root?
       subject == :_ && predicate == :_ && object == :_
     end
 
     def variables
-      array_form.select { |e| self.class.variable? e }
-    end
-
-    def contains? var
-      self.class.variable?( var ) && array_form.include?( var )
+      [].tap do |a|
+        a << subject if Template.variable?( subject )
+        a << predicate if Template.variable?( predicate )
+        a << object if Template.variable?( object )
+      end
     end
 
     def hash
-      @hash ||= array_form.map( &:hash ).hash
+      @hash ||= [subject.hash, predicate.hash, object.hash].hash
     end
 
     def self.hash_for *args
       args.map( &:hash ).hash
     end
 
-    def === wme
-      wme =~ self if WME === wme
-    end
-
     def == other
-      return false unless Template === other
-      subject == other.subject && predicate == other.predicate && object == other.object
+      other.is_a?(Template) && subject == other.subject && predicate == other.predicate && object == other.object
     end
 
     def =~ template
@@ -64,66 +40,36 @@ module Wongi::Engine
         ( template.predicate == :_ || template.predicate == predicate ) &&
         ( template.object == :_ || template.object == object )
       else
-        raise "Templates can only match templates"
+        raise Error, "templates can only match other templates"
       end
     end
 
-
-    def compile context
-      tests, assignment = *JoinNode.compile( self, context.earlier, context.parameters )
-      alpha = context.rete.compile_alpha( self )
-      context.node = context.node.beta_memory.join_node( alpha, tests, assignment, context.alpha_deaf )
-      context.node.context = context
-      context.node.debug = debug?
-      context.earlier << self
-      context
-    end
-
     def inspect
-      "<~ #{subject.inspect} #{predicate.inspect} #{object.inspect} #{time}>"
+      "<~#{subject.inspect} #{predicate.inspect} #{object.inspect}>"
     end
 
     def to_s
       inspect
     end
 
-    private
-
-    def array_form
-      @array_form ||= [ subject, predicate, object ]
-    end
-
-  end
-
-  class NegTemplate < Template
-
-    # :arg: context => Wongi::Rete::BetaNode::CompilationContext
-    def compile context
-      tests, assignment = *JoinNode.compile( self, context.earlier, context.parameters )
-      raise DefinitionError.new("Negative matches may not introduce new variables: #{assignment.variables}") unless assignment.root?
-      alpha = context.rete.compile_alpha( self )
-      context.node = context.node.neg_node( alpha, tests, context.alpha_deaf, unsafe )
-      context.node.context = context
-      context.node.debug = debug?
-      context.earlier << self
-      context
-    end
-  end
-
-  class OptionalTemplate < Template
-
-    def compile context
-      tests, assignment = *JoinNode.compile( self, context.earlier, context.parameters )
-      alpha = context.rete.compile_alpha( self )
-      context.node = context.node.beta_memory.optional_node( alpha, tests, assignment, context.alpha_deaf )
-      context.node.context = context
-      context.node.debug = debug?
-      context.earlier << self
-      context
+    def resolve!(token)
+      s = if Template.variable?(subject)
+        token[subject].tap { |x| raise DefinitionError, "unbound variable #{subject} in token #{token}" unless x}
+      else
+        subject
+      end
+      p = if Template.variable?(predicate)
+        token[predicate].tap { |x| raise DefinitionError, "unbound variable #{predicate} in token #{token}" unless x}
+      else
+        predicate
+      end
+      o = if Template.variable?(object)
+        token[object].tap { |x| raise DefinitionError, "unbound variable #{object} in token #{token}" unless x}
+      else
+        object
+      end
+      [s, p, o]
     end
 
   end
-
-
-
 end