ruleby 0.1 → 0.2

data/lib/core/patterns.rb

@@ -103,115 +103,5 @@ module Ruleby
     end
   end  
   
-  class MatchContext
-    def initialize(fact_id=nil, match_results=[])
-      @match_hash = DoubleHash.new fact_id, match_results
-    end
-    
-    def clear
-      @match_hash = DoubleHash.new
-    end
-     
-    def add(ids,mr)
-      @match_hash.add ids, mr
-    end
-    
-    def add_uniq(ids,mr)
-      @match_hash.add_uniq ids, mr
-    end
-        
-    def each_match_result
-      @match_hash.each do |ids,mr|     
-        yield(ids,mr)
-      end
-    end
-    
-    def each_fact_id
-      @match_hash.each_id do |id|
-        yield(id)
-      end
-    end
-    
-    def contains?(mr)
-      return @match_hash.value?(mr)
-    end
-    
-    def +(mc)
-      # TODO make better
-      new_mc = MatchContext.new
-      new_mc.match_hash = @match_hash + mc.match_hash
-      return new_mc
-    end
-    
-    def concat(match_context)
-      @match_hash.concat match_context.match_hash
-      return self
-    end
-    
-    def concat_uniq(match_context)
-      @match_hash.concat_uniq match_context.match_hash
-      return self
-    end
-    
-    def default
-      return @match_hash.default
-    end
-        
-    def remove(id)
-      return @match_hash.remove(id)
-    end
-    
-    def delete_if
-      @match_hash.delete_if do |mr|  
-        yield(mr)
-      end
-    end
-    
-    def match_results
-      v = @match_hash.values
-      if v.kind_of?(Hash)
-        # QUESTION What the heck is going on here?  Why did this return a Hash
-        # instead of an Array?
-        return v.values
-      end
-      return v
-    end
-    
-    def dup
-      dup_mc = MatchContext.new
-      dup_mc.match_hash = @match_hash.dup
-      return dup_mc
-    end
-    
-    def subset(fact_id)
-      mrs = @match_hash.values_by_id(fact_id)
-      return MatchContext.new(fact_id, mrs.dup)
-    end
-    
-    def satisfied?
-      return !@match_hash.values.empty? 
-    end
-    
-    def to_s
-      s = '[MatchContext('
-      each_match_result do |ids,mr|
-        s = s + "[#{ids.join(',')}->#{mr}]"
-      end
-      s = s + ')]'
-    end
-            
-    def ==(mc)
-      return false if mc == nil
-      mc.match_hash.keys.each do |id|
-        return false if @match_hash.keys.index(id) == nil
-      end
-      mc.match_results.values.each do |mr|
-        return false if match_results.values.index(mr) == nil
-      end
-      return true
-    end
-    
-    attr :match_hash, true
-  end
 end
 end

data/lib/core/utils.rb

@@ -1,100 +1,32 @@
 module Ruleby
   module Core
   
-  # We use this custom structure for our data so that we can hash the nodes by
-  # the type they represent.  This allows for faster results because we can limit
-  # the number of nodes we compare against.  In addition, this class does some of
-  # the compiling of the rules when a node is added.
-  class NodeNetworkArray
-    def initialize
-      @nodes = {}
-    end
-    
-    def each(clazz)
-      nodes = @nodes[clazz]
-      if nodes
-        nodes.each do |n|
-          yield n
-        end
-      end
-    end
-    
-    def each_internal
-      @nodes.values.flatten.each do |n|
-        yield n
-      end
-    end
-    private:each_internal
-    
-    def has_node(node)
-      @nodes[node.pattern.head].each do |node2|
-        if node2 == node
-          return true
-        end
-      end
-      return false
-    end
-    
-    def add_internal(node)
-      nodes = @nodes[node.pattern.head]
-      nodes = [] unless nodes
-      nodes.push node
-      @nodes[node.pattern.head] = nodes
-    end
-    private:add_internal
-    
-    # This method adds a node to our list.  In addition, it creates bindings between
-    # this node and any nodes that it references or is referenced by
-    def add(object_node)
-      object_node.pattern.atoms.each do |atom|
-        if (atom.kind_of?(ReferenceAtom))
-          each_internal do |local_node|
-            added = false
-            atom.vars.each do |var|                
-              local_node.pattern.atoms.each do |local_atom|                            
-                if (var == local_atom.tag)                     
-                  atom.var_atoms[var] = local_atom
-                  unless added
-                    local_node.referenced_by.push object_node 
-                    added = true
-                  end
-                end
-              end        
-            end
-          end
-        end
-        unless atom
-          # TODO it would be better to throw this exception before the 
-          # the rule is asserted
-          raise "Reference not found for: " + atom.tag.to_s
-        end
-      end       
-      add_internal(object_node);     
-    end
-    
-  end
-  
   # This class is used when we need to have a Hash where keys and values are mapped 
-  # many-to-many.  This class allows for quick access of both key and value.
-  class DoubleHash
-    def initialize(fact_id=nil, values=[])
+  # many-to-many.  This class allows for quick access of both key and value.  It
+  # is similar to Multimap in C++ standard lib.
+  class MultiHash
+    def initialize(key=nil, values=[])
       @i = 0
       clear
-      if fact_id
-        @fact_ids = {fact_id => []} 
+      if key
+        @keys = {key => []} 
         values.each do |v|
-          key = generate_key()
-          key_list = @fact_ids[fact_id]
-          key_list.push key
-          @fact_ids[fact_id] = key_list
-          @values = {key => v}
-          @backward_hash = {key => [fact_id]}
+          xref = generate_xref()
+          xref_list = @keys[key]
+          xref_list.push xref
+          @keys[key] = xref_list
+          @values = {xref => v}
+          @backward_hash = {xref => [key]}
         end
       end
     end
     
+    def empty?
+      return @keys.empty?
+    end
+    
     def rehash
-      @fact_ids.rehash
+      @keys.rehash
       @values.rehash
       @backward_hash.rehash
     end
@@ -104,16 +36,16 @@ module Ruleby
     end
     
     def clear
-      @fact_ids = {}
+      @keys = {}
       @values = {}
       @backward_hash = {}
     end
     
     def values_by_id(id)
-      keys = @fact_ids[id]
+      xrefs = @keys[id]
       values = []
-      if keys
-        keys.each do |k|
+      if xrefs
+        xrefs.each do |k|
           values.push @values[k]
         end
       else
@@ -122,95 +54,103 @@ module Ruleby
       return values
     end
     
-    def each_id
-      @fact_ids.each_key do |id|
-        yield(id)
+    def each_key
+      @keys.each_key do |key|
+        yield(key)
       end
     end
     
-    def has_id?(id)
-      return @fact_ids.has_key?(id)
+    def has_key?(key)
+      return @keys.has_key?(key)
+    end
+    
+    def key?(key)
+      return has_key?(key)
     end
     
     def +(dh)
-      # TODO this can be much faster
+      # TODO this can be faster
       new_dh = dh.dup
       dh.concat self.dup
       return new_dh
     end
      
     def add(ids,val)
-      key = generate_key()      
+      xref = generate_xref()      
       ids.each do |id|
-        key_list = @fact_ids[id]
-        key_list = [] if key_list == @fact_ids.default
-        key_list.push key             
-        @fact_ids[id] = key_list  
+        xref_list = @keys[id]
+        xref_list = [] if xref_list == @keys.default
+        xref_list.push xref             
+        @keys[id] = xref_list  
       end       
-      @values[key] = val    
-      @backward_hash[key] = ids
+      @values[xref] = val    
+      @backward_hash[xref] = ids
     end
     
+    # WARN this method adds a value to the MultiHash only if it is unique.  It
+    # can be a fairly costly operation, and should be avoided.  We only 
+    # implemented this as part of a hack to get things working early on.
     def add_uniq(ids,val)
-      key = generate_key()
+      xref = generate_xref()
       exist_list = []
       ids.each do |id|
-        key_list = @fact_ids[id]
-        if key_list != @fact_ids.default           
-          key_list.each do |existing_key|  
-            existing_val = @values[existing_key] 
+        xref_list = @keys[id]
+        if xref_list != @keys.default           
+          xref_list.each do |existing_xref|  
+            existing_val = @values[existing_xref] 
             if existing_val 
               if val == existing_val                        
-                key = existing_key 
+                xref = existing_xref 
                 exist_list.push id
                 break
               end
             else
-              # HACK there shouldn't be any keys like this in the
+              # HACK there shouldn't be any xrefs like this in the
               # hash to being with.  Why are they there?
-              key_list.delete(existing_key)
-              @fact_ids[id] = key_list
+              xref_list.delete(existing_xref)
+              @keys[id] = xref_list
             end
           end         
         end             
       end   
       add_list = ids - exist_list   
       add_list.each do |id|
-        key_list = @fact_ids[id]
-        key_list = [] if key_list == @fact_ids.default
-        key_list.push key             
-        @fact_ids[id] = key_list  
+        xref_list = @keys[id]
+        xref_list = [] if xref_list == @keys.default
+        xref_list.push xref             
+        @keys[id] = xref_list  
       end            
-      @values[key] = val if exist_list.empty?
-      b_list = @backward_hash[key]
+      @values[xref] = val if exist_list.empty?
+      b_list = @backward_hash[xref]
       if b_list
-        @backward_hash[key] = b_list | ids
+        @backward_hash[xref] = b_list | ids
       else
-        @backward_hash[key] = ids
+        @backward_hash[xref] = ids
       end
     end
         
     def each
-      @values.each do |key,val|
-        ids = @backward_hash[key]        
+      @values.each do |xref,val|
+        ids = @backward_hash[xref]        
         yield(ids,val)
       end
     end
     
     def each_internal
-      @values.each do |key,val|
-        ids = @backward_hash[key]
-        yield(ids,key,val)
+      @values.each do |xref,val|
+        ids = @backward_hash[xref]
+        yield(ids,xref,val)
       end      
     end
     private:each_internal
     
-    def concat(double_hash)
-      double_hash.each do |ids,val|
+    def concat(multi_hash)
+      multi_hash.each do |ids,val|
         add(ids,val)
       end
     end
     
+    # WARN see comments in add_uniq
     def concat_uniq(double_hash)
       double_hash.each do |ids,val|
         add_uniq(ids,val)
@@ -222,58 +162,58 @@ module Ruleby
     end
         
     def remove(id)      
-      key_list = @fact_ids.delete(id)
-      if key_list != @fact_ids.default
+      xref_list = @keys.delete(id)
+      if xref_list != @keys.default
         removed_values = []
-        key_list.each do |key|
-          value = @values.delete(key)
+        xref_list.each do |xref|
+          value = @values.delete(xref)
           removed_values.push value
-          id_list = @backward_hash.delete(key)
+          id_list = @backward_hash.delete(xref)
           id_list.each do |next_id|
-            remove_internal(next_id,key) if next_id != id
+            remove_internal(next_id,xref) if next_id != id
           end
         end
         return removed_values
       else
-#        puts 'WARN: tried to remove from DoubleHash where id does not exist'        
+#        puts 'WARN: tried to remove from MultiHash where id does not exist'        
         return default
       end
     end
     
-    def remove_internal(id,key)
-      key_list = @fact_ids[id]
-      if key_list # BUG this shouldn't be nil!
-        key_list.delete(key) 
-        if key_list.empty?
-          @fact_ids.delete(id)
+    def remove_internal(id,xref)
+      xref_list = @keys[id]
+      if xref_list # BUG this shouldn't be nil!
+        xref_list.delete(xref) 
+        if xref_list.empty?
+          @keys.delete(id)
         else             
-          @fact_ids[id] = key_list
+          @keys[id] = xref_list
         end
       end
     end
     private:remove_internal
     
-    def remove_by_key(ids,key)
+    def remove_by_xref(ids,xref)
       ids.each do |id|
-        key_list = @fact_ids[id]
-        key_list.delete(key) 
-        if key_list.empty?
-          @fact_ids.delete(id)
+        xref_list = @keys[id]
+        xref_list.delete(xref) 
+        if xref_list.empty?
+          @keys.delete(id)
         else             
-          @fact_ids[id] = key_list
+          @keys[id] = xref_list
         end
       end
-      @values.delete(key)
-      @backward_hash.delete(key)
+      @values.delete(xref)
+      @backward_hash.delete(xref)
     end
-    private:remove_by_key
+    private:remove_by_xref
     
     def delete_if
-      @values.delete_if do |key,v|  
+      @values.delete_if do |xref,v|  
         if yield(v)
-          id_list = @backward_hash.delete(key)
+          id_list = @backward_hash.delete(xref)
           id_list.each do |next_id|
-            remove_internal(next_id,key)
+            remove_internal(next_id,xref)
           end
           true
         else
@@ -287,66 +227,66 @@ module Ruleby
     end
     
     def keys
-      return @fact_ids.keys
+      return @keys.keys
     end
     
     def dup
-      dup_mc = DoubleHash.new
+      dup_mc = MultiHash.new
       each do |ids,v|
         dup_mc.add ids, v.dup
       end
       return dup_mc      
     end
     
-    def generate_key()
+    def generate_xref()
       @i = @i + 1
       return @i
     end
-    private:generate_key
+    private:generate_xref
     
     # This method is for testing.  It ensures that all the Hash's
-    # and Array's are in order, and not corrupted (ex. some fact_id points
-    # to a key that does not exist in the match_results Hash).
+    # and Array's are in order, and not corrupted (ex. some key points
+    # to a xref that does not exist in the match_results Hash).
     def valid?
-      @fact_ids.each do |id,keys|
-#        key_list = @fact_ids[id]
-#        if key_list != @fact_ids.default
-#          key_list.each do |key|
-#            id_list = @backward_hash[key]
+      @keys.each do |id,xrefs|
+#        xref_list = @keys[id]
+#        if xref_list != @keys.default
+#          xref_list.each do |xref|
+#            id_list = @backward_hash[xref]
 #            unless id_list
 #              puts 'yup' 
 #              return false
 #            end
 #          end
 #        end
-        keys.each do |key|
+        xrefs.each do |xref|
           count = 0
-          keys.each do |key2|
-            if key == key2 
+          xrefs.each do |xref2|
+            if xref == xref2 
               count = count + 1
               if count > 1
-                puts '(0) Duplicate keys in entry for fact_ids' 
+                puts '(0) Duplicate xrefs in entry for keys' 
                 return false
               end
             end
           end
         
-          mr = @match_results[key] 
+          mr = @match_results[xref] 
           if mr == @match_results.default
-            puts '(1) Missing entry in @match_results for key' 
+            puts '(1) Missing entry in @match_results for xref' 
             return false
           end
           
-#          @match_results.each do |mr_key,other_mr|
-#            if other_mr == mr && mr_key != key
+#          @match_results.each do |mr_xref,other_mr|
+#            if other_mr == mr && mr_xref != xref
 #              puts '(1a) Duplicate entry in @match_results'
 #              return false
 #            end
 #          end
           
-          id_list = @backward_hash[key]
+          id_list = @backward_hash[xref]
           if id_list == @backward_hash.default
-            puts '(2) Missing entry in backward_hash for key'
+            puts '(2) Missing entry in backward_hash for xref'
             return false
           end
           
@@ -357,16 +297,16 @@ module Ruleby
                     
           id_list.each do |ref_id|
             unless ref_id == id
-              ref_key_list = @fact_ids[ref_id]
-              if ref_key_list == @fact_ids.default
-                puts '(4) Missing entry in fact_ids for backward_hash id'
-                puts "#{id},#{mr},#{key},#{ref_id}"
+              ref_xref_list = @keys[ref_id]
+              if ref_xref_list == @keys.default
+                puts '(4) Missing entry in keys for backward_hash id'
+                puts "#{id},#{mr},#{xref},#{ref_id}"
                 return false
               end
               
-              if ref_key_list.index(key) == nil                
-                puts '(5) Entry in fact_ids is missing key'
-                puts "#{id},#{mr},#{key},#{ref_id}"
+              if ref_xref_list.index(xref) == nil                
+                puts '(5) Entry in keys is missing xref'
+                puts "#{id},#{mr},#{xref},#{ref_id}"
                 return false
               end
             end
@@ -381,10 +321,6 @@ module Ruleby
       # TODO need to implement this
       return super
     end
-       
-    attr_reader :fact_ids
-    attr_reader :values
-    attr_reader :backward_hash
   end
 end
 end