ruleby 0.1

data/lib/core/patterns.rb

@@ -0,0 +1,217 @@
+module Ruleby
+  module Core
+
+  class Pattern
+    # a list of AtomTag objects
+    attr_reader :atom_tags 
+  end
+  
+  class ObjectPattern < Pattern
+  
+    # 'head' is a class type
+    def initialize(tag, head, atoms)
+      init_vars tag, head, atoms   
+    end
+    
+    def init_vars(tag,head,atoms,match=true)
+      @head = head
+      @headatom = TypeAtom.new tag, :class do |t| t == head end
+      @atoms = [@headatom] + atoms          
+      @atom_tags = @atoms.collect {|a| AtomTag.new a.tag, match}      
+    end
+      
+    attr_reader :head
+    attr_reader :atoms
+    attr_reader :atom_tags
+    
+    def ==(pattern)
+      atoms = pattern.atoms
+      if(@atoms.size == atoms.size)
+        (0..@atoms.size).each do |i|
+          if !(@atoms[i] == atoms[i])
+            return false
+          end
+        end
+        return true
+      end
+      return false
+    end
+   
+    def to_s
+      return '(' + @atoms.join('|') + ')'
+    end
+  end
+  
+  class NotPattern < ObjectPattern
+    def initialize(tag, head, atoms)             
+      init_vars tag, head, atoms, false     
+    end
+    
+    def ==(pattern)
+      return pattern.kind_of?(NotPattern) && super==(pattern)
+    end
+  end
+  
+  class CompositePattern < Pattern
+    
+    def initialize(left_pattern, right_pattern)
+      @left_pattern = left_pattern
+      @right_pattern = right_pattern
+    end
+    
+    attr_reader :left_pattern, :right_pattern
+    
+    def atoms
+      atoms = []
+      atoms.push @left_pattern.atoms
+      atoms.push @right_pattern.atoms
+      return atoms
+    end
+  end
+  
+  class AndPattern < CompositePattern
+  
+    def initialize(left_pattern, right_pattern)
+      super(left_pattern, right_pattern)
+      @head = :and
+      @atom_tags = left_pattern.atom_tags.concat(right_pattern.atom_tags)      
+    end
+     
+  end
+  
+  class OrPattern < CompositePattern
+    
+    def initialize(left_pattern, right_pattern)
+      super(left_pattern, right_pattern)
+      @head = :or
+      @atom_tags = [[left_pattern.atom_tags, right_pattern.atom_tags]]
+    end
+
+  end
+  
+  class AtomTag
+    def initialize(tag, exists=true)
+      @tag = tag
+      
+      # QUESTION can we get rid of this property?  if so, we may not need this
+      # class at all.
+      @exists = exists 
+    end
+    attr_reader :tag,:exists
+    def to_s
+      return "[#{@tag.to_s}]" 
+    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

@@ -0,0 +1,390 @@
+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=[])
+      @i = 0
+      clear
+      if fact_id
+        @fact_ids = {fact_id => []} 
+        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]}
+        end
+      end
+    end
+    
+    def rehash
+      @fact_ids.rehash
+      @values.rehash
+      @backward_hash.rehash
+    end
+    
+    def value?(mr)
+      @values.value?(mr)
+    end
+    
+    def clear
+      @fact_ids = {}
+      @values = {}
+      @backward_hash = {}
+    end
+    
+    def values_by_id(id)
+      keys = @fact_ids[id]
+      values = []
+      if keys
+        keys.each do |k|
+          values.push @values[k]
+        end
+      else
+        #???
+      end
+      return values
+    end
+    
+    def each_id
+      @fact_ids.each_key do |id|
+        yield(id)
+      end
+    end
+    
+    def has_id?(id)
+      return @fact_ids.has_key?(id)
+    end
+    
+    def +(dh)
+      # TODO this can be much faster
+      new_dh = dh.dup
+      dh.concat self.dup
+      return new_dh
+    end
+     
+    def add(ids,val)
+      key = generate_key()      
+      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  
+      end       
+      @values[key] = val    
+      @backward_hash[key] = ids
+    end
+    
+    def add_uniq(ids,val)
+      key = generate_key()
+      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] 
+            if existing_val 
+              if val == existing_val                        
+                key = existing_key 
+                exist_list.push id
+                break
+              end
+            else
+              # HACK there shouldn't be any keys like this in the
+              # hash to being with.  Why are they there?
+              key_list.delete(existing_key)
+              @fact_ids[id] = key_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  
+      end            
+      @values[key] = val if exist_list.empty?
+      b_list = @backward_hash[key]
+      if b_list
+        @backward_hash[key] = b_list | ids
+      else
+        @backward_hash[key] = ids
+      end
+    end
+        
+    def each
+      @values.each do |key,val|
+        ids = @backward_hash[key]        
+        yield(ids,val)
+      end
+    end
+    
+    def each_internal
+      @values.each do |key,val|
+        ids = @backward_hash[key]
+        yield(ids,key,val)
+      end      
+    end
+    private:each_internal
+    
+    def concat(double_hash)
+      double_hash.each do |ids,val|
+        add(ids,val)
+      end
+    end
+    
+    def concat_uniq(double_hash)
+      double_hash.each do |ids,val|
+        add_uniq(ids,val)
+      end
+    end
+    
+    def default
+      return @values.default
+    end
+        
+    def remove(id)      
+      key_list = @fact_ids.delete(id)
+      if key_list != @fact_ids.default
+        removed_values = []
+        key_list.each do |key|
+          value = @values.delete(key)
+          removed_values.push value
+          id_list = @backward_hash.delete(key)
+          id_list.each do |next_id|
+            remove_internal(next_id,key) if next_id != id
+          end
+        end
+        return removed_values
+      else
+#        puts 'WARN: tried to remove from DoubleHash 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)
+        else             
+          @fact_ids[id] = key_list
+        end
+      end
+    end
+    private:remove_internal
+    
+    def remove_by_key(ids,key)
+      ids.each do |id|
+        key_list = @fact_ids[id]
+        key_list.delete(key) 
+        if key_list.empty?
+          @fact_ids.delete(id)
+        else             
+          @fact_ids[id] = key_list
+        end
+      end
+      @values.delete(key)
+      @backward_hash.delete(key)
+    end
+    private:remove_by_key
+    
+    def delete_if
+      @values.delete_if do |key,v|  
+        if yield(v)
+          id_list = @backward_hash.delete(key)
+          id_list.each do |next_id|
+            remove_internal(next_id,key)
+          end
+          true
+        else
+          false
+        end
+      end
+    end
+    
+    def values
+      return @values.values
+    end
+    
+    def keys
+      return @fact_ids.keys
+    end
+    
+    def dup
+      dup_mc = DoubleHash.new
+      each do |ids,v|
+        dup_mc.add ids, v.dup
+      end
+      return dup_mc      
+    end
+    
+    def generate_key()
+      @i = @i + 1
+      return @i
+    end
+    private:generate_key
+    
+    # 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).
+    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]
+#            unless id_list
+#              puts 'yup' 
+#              return false
+#            end
+#          end
+#        end
+        keys.each do |key|
+          count = 0
+          keys.each do |key2|
+            if key == key2 
+              count = count + 1
+              if count > 1
+                puts '(0) Duplicate keys in entry for fact_ids' 
+                return false
+              end
+            end
+          end
+        
+          mr = @match_results[key] 
+          if mr == @match_results.default
+            puts '(1) Missing entry in @match_results for key' 
+            return false
+          end
+          
+#          @match_results.each do |mr_key,other_mr|
+#            if other_mr == mr && mr_key != key
+#              puts '(1a) Duplicate entry in @match_results'
+#              return false
+#            end
+#          end
+          
+          id_list = @backward_hash[key]
+          if id_list == @backward_hash.default
+            puts '(2) Missing entry in backward_hash for key'
+            return false
+          end
+          
+          if id_list.index(id) == nil
+            puts '(3) Entry in backward_hash is missing id'
+            return false
+          end
+                    
+          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}"
+                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}"
+                return false
+              end
+            end
+          end
+        end
+      end           
+      return true
+    end
+    private:valid?
+     
+    def ==(dh)
+      # TODO need to implement this
+      return super
+    end
+       
+    attr_reader :fact_ids
+    attr_reader :values
+    attr_reader :backward_hash
+  end
+end
+end