ruleby 0.2 → 0.3

data/lib/core/patterns.rb

@@ -1,28 +1,37 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
 module Ruleby
   module Core
 
   class Pattern
-    # a list of AtomTag objects
-    attr_reader :atom_tags 
   end
   
+  # This class represents a pattern that is looking for the existence of some
+  # object. It contains a list of 'atoms' that represent the properties of
+  # the class that we are looking for.
   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
+    
+    # 'deftemplate' is a class type
+    def initialize(tag, deftemplate, atoms)
+      init_vars tag, deftemplate, atoms   
+    end
+    
+    def init_vars(tag,deftemplate,atoms)
+      @head = TypeAtom.new tag, deftemplate 
+      @atoms = [@head] + atoms              
+    end      
     
     def ==(pattern)
       atoms = pattern.atoms
@@ -42,24 +51,27 @@ module Ruleby
     end
   end
   
+  # This class represents a pattern that is looking for the absence of some
+  # object (rather than the existence of).  In all respects, it is the same as
+  # an ObjectPattern, but it is handled differently by the inference engine.
   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
   
+  # A composite pattern represents a logical conjunction of two patterns.  The
+  # inference engine interprets this differently from an ObjectPattern because
+  # it simply aggregates patterns.  
   class CompositePattern < Pattern
+        
+    attr_reader :left_pattern
+    attr_reader :right_pattern
     
     def initialize(left_pattern, right_pattern)
       @left_pattern = left_pattern
       @right_pattern = right_pattern
-    end
-    
-    attr_reader :left_pattern, :right_pattern
+    end    
     
     def atoms
       atoms = []
@@ -73,8 +85,7 @@ module Ruleby
   
     def initialize(left_pattern, right_pattern)
       super(left_pattern, right_pattern)
-      @head = :and
-      @atom_tags = left_pattern.atom_tags.concat(right_pattern.atom_tags)      
+      @head = :and    
     end
      
   end
@@ -84,24 +95,10 @@ module Ruleby
     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  
+
   
 end
 end

data/lib/core/utils.rb

@@ -1,9 +1,145 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
 module Ruleby
   module Core
   
-  # 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.  It
-  # is similar to Multimap in C++ standard lib.
+  # This class is a wrapper for the context under which the network executes for
+  # for a given fact.  It is essentially a wrapper for a fact and a partial
+  # match.
+  class MatchContext
+  
+    attr_reader:fact
+    attr_reader:match
+    
+    def initialize(fact,mr)
+      @fact = fact      
+      @match = mr  
+    end
+    
+    def to_s
+      return @match.to_s
+    end
+    
+    def ==(t)
+      return t && @fact == t.fact && @match == t.match
+    end
+  end
+    
+  # This class represents a partial match.  It contains the variables, values,
+  # and some metadata about the match.  For the most part, this metadata is used
+  # during conflict resolution.
+  class MatchResult    
+    # TODO this class needs to be cleaned up so that we don't have a bunch of
+    # properties.  Instead, maybe it sould have a list of facts.    
+    
+    attr :variables, true
+    attr :is_match, true
+    attr :fact_hash, true
+    attr :recency, true
+    
+    def initialize(variables=Hash.new,is_match=false,fact_hash={},recency=[])
+      @variables = variables      
+      
+      # a list of recencies of the facts that this matchresult depends on.
+      @recency = recency
+      
+      # notes where this match result is from a NotPattern or ObjectPattern
+      # TODO this isn't really needed anymore.  how can we get rid of it?
+      @is_match = is_match 
+      
+      # a hash of fact.ids that each tag corresponds to
+      @fact_hash = fact_hash 
+    end
+    
+    def []=(sym, object)
+      @variables[sym] = object
+    end
+    
+    def [](sym)
+       return @variables[sym]
+    end
+    
+    def fact_ids
+      return fact_hash.values.uniq
+    end
+    
+    def ==(match)           
+      return match != nil && @variables == match.variables && @is_match == match.is_match && @fact_hash == match.fact_hash
+    end
+    
+    def key?(m)
+      return @variables.key?(m)
+    end
+    
+    def keys
+      return @variables.keys
+    end
+    
+    def update(mr)
+      @recency = @recency | mr.recency
+      @is_match = mr.is_match
+      @variables = @variables.update mr.variables      
+      @fact_hash = @fact_hash.update mr.fact_hash      
+      return self
+    end
+    
+    def dup     
+      dup_mr = MatchResult.new
+      dup_mr.recency = @recency.clone
+      dup_mr.is_match = @is_match
+      dup_mr.variables = @variables.clone
+      dup_mr.fact_hash = @fact_hash.clone       
+      return dup_mr
+    end
+    
+    def merge!(mr)
+      return update(mr)
+    end
+    
+    def merge(mr)
+      new_mr = MatchResult.new
+      new_mr.recency = @recency | mr.recency
+      new_mr.is_match = mr.is_match
+      new_mr.variables = @variables.merge mr.variables 
+      new_mr.fact_hash = @fact_hash.merge mr.fact_hash    
+      return new_mr
+    end
+    
+    def clear
+      @variables = {}
+      @fact_hash = {}
+      @recency = []
+    end
+    
+    def delete(tag)
+      @variables.delete(tag)
+      @fact_hash.delete(tag)
+    end
+    
+    def to_s
+      s = '#MatchResult('
+      s = s + 'f)(' unless @is_match
+      s = s + object_id.to_s+')('
+      @variables.each do |key,value|
+        s += "#{key}=#{value}/#{@fact_hash[key]}, "
+      end
+      return s + ")"
+    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.  It is similar to Multimap in C++ standard lib.
+  # This thing is a mess (and barely works). It needs to be refactored.
   class MultiHash
     def initialize(key=nil, values=[])
       @i = 0
@@ -87,6 +223,7 @@ module Ruleby
       @backward_hash[xref] = ids
     end
     
+    # DEPRECATED
     # 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.
@@ -150,6 +287,7 @@ module Ruleby
       end
     end
     
+    # DEPRECATED
     # WARN see comments in add_uniq
     def concat_uniq(double_hash)
       double_hash.each do |ids,val|

data/lib/dsl/ferrari.rb

@@ -0,0 +1,263 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
+module Ruleby
+  module Ferrari
+    class RulebookHelper    
+      def initialize(engine)
+        @engine = engine
+      end
+    
+      attr_reader :engine
+    
+      def rule(name, *args, &block) 
+        options = args[0].kind_of?(Hash) ? args.shift : {}        
+        
+        r = RuleBuilder.new name
+        args.each do |arg|
+          if arg.kind_of? Array
+            r.when(*arg)
+          else
+            raise 'Invalid condition.  All or none must be Arrays.'
+          end
+        end
+        
+        r.then(&block)
+        r.priority = options[:priority] if options[:priority]
+        
+        @engine.assert_rule(r.build_rule)
+      end
+      
+    end
+    
+    class RuleBuilder
+    
+      def initialize(name, pattern=nil, action=nil, priority=0) 
+        @name = name
+        @pattern = pattern
+        @action = action  
+        @priority = priority    
+        
+        @tags = {}
+        @methods = {}
+        @when_counter = 0
+      end   
+        
+      def when(*args)
+        clazz = args.shift
+        is_not = false
+        if clazz == :not || clazz == :~
+          clazz = args.shift
+          is_not = true
+        elsif clazz == :exists
+          raise 'The \'exists\' quantifier is not yet supported.'
+        end
+        
+        head_tag = nil
+        atoms = []
+        @when_counter += 1
+        
+        if args[0].kind_of?(Symbol)
+          head_tag = args.shift
+          @tags[head_tag] = @when_counter
+        else
+          head_tag = GeneratedTag.new
+          @tags[head_tag] = @when_counter
+        end
+        
+        args.each do |arg|
+          if arg.kind_of? Hash
+            arg.each do |ab,tag|
+              ab.tag = tag
+              ab.clazz = clazz
+              @tags[tag] = @when_counter
+              @methods[tag] = ab.name
+              atoms.push ab.build_atom(@tags, @methods, @when_counter)   
+            end
+          elsif arg.kind_of? AtomBuilder
+            arg.tag = GeneratedTag.new
+            arg.clazz = clazz
+            @methods[arg.tag] = arg.name
+            atoms.push arg.build_atom(@tags, @methods, @when_counter)
+          elsif arg == false
+            raise 'The != operator is not allowed.'
+          else
+            raise "Invalid condition: #{arg}"
+          end
+        end  
+        
+        p = is_not ? Core::NotPattern.new(head_tag, clazz, atoms) : 
+                     Core::ObjectPattern.new(head_tag, clazz, atoms)
+        @pattern = @pattern ? Core::AndPattern.new(@pattern, p) : p
+        
+        return nil
+      end
+      
+      def then(&block)
+        @action = Core::Action.new(&block)  
+        @action.name = @name
+        @action.priority = @priority
+      end
+          
+      def priority
+        return @priority
+      end
+      
+      def priority=(p)
+        @priority = p
+        @action.priority = @priority
+      end 
+        
+      def build_rule
+        Core::Rule.new @name, @pattern, @action, @priority
+      end
+    end
+    
+    class MethodBuilder  
+      public_instance_methods.each do |m|
+        a = [:method_missing, :new, :public_instance_methods, :__send__, :__id__]
+        undef_method m.to_sym unless a.include? m.to_sym
+      end
+    
+      def method_missing(method_id, *args, &block)
+        ab = AtomBuilder.new method_id
+        if block_given?
+          args.each do |arg|   
+            ab.bindings.push BindingBuilder.new(arg, method_id)
+          end
+          ab.block = block
+        elsif args.size > 0
+          puts args.class.to_s + ' --- ' + args.to_s
+          raise 'Arguments not supported for short-hand conditions' 
+        end
+        return ab
+      end
+    end
+    
+    class BindingBuilder  
+      attr_accessor :tag, :method
+      def initialize(tag,method=nil)
+        @tag = tag
+        @method = method
+      end
+      
+      def +(arg)
+        raise 'Cannot use operators in short-hand mode!'
+      end
+      
+      def -(arg)
+        raise 'Cannot use operators in short-hand mode!'
+      end
+      
+      def /(arg)
+        raise 'Cannot use operators in short-hand mode!'
+      end
+      
+      def *(arg)
+        raise 'Cannot use operators in short-hand mode!'
+      end
+      
+      def to_s
+        "BindingBuilder @tag=#{@tag}, @method=#{@method}"
+      end
+    end
+    
+    class AtomBuilder
+      attr_accessor :tag, :name, :bindings, :clazz, :block
+      
+      def initialize(name)   
+        @name = name
+        @clazz = nil
+        @tag = nil
+        @bindings = []
+        @block = lambda {|x| true}
+      end
+      
+      def method_missing(method_id, *args, &block)
+        if method_id == :not
+          return NotOperatorBuilder.new(@name)
+        end
+      end
+      
+      def ==(value)
+        create_block value, lambda {|x,y| x == y}, lambda {|x| x == value}; self
+      end
+      
+      def >(value)
+        create_block value, lambda {|x,y| x > y}, lambda {|x| x > value}; self
+      end
+      
+      def <(value)
+        create_block value, lambda {|x,y| x < y}, lambda {|x| x < value}; self
+      end
+      
+      def =~(value)
+        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
+      end
+      
+      def <=(value)
+        create_block value, lambda {|x,y| x <= y}, lambda {|x| x <= value}; self
+      end
+      
+      def >=(value)
+        create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= value}; self
+      end  
+      
+      def build_atom(tags=nil,methods=nil,when_id=nil)
+        
+        raise 'Syntax error in Rules: class not set' unless @clazz   
+        
+        return Core::TypeAtom.new(@tag, @clazz) unless tags || when_id
+            
+        return Core::PropertyAtom.new(@tag, @name, @clazz, &@block) if @bindings.empty?
+        
+        if references_self?(tags,when_id)
+          bind_methods = @bindings.collect{ |bb| methods[bb.tag] }
+          Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@clazz,&@block)
+        else
+          bind_tags = @bindings.collect{ |bb| bb.tag }
+          Core::ReferenceAtom.new(@tag,@name,bind_tags,@clazz,&@block)
+        end
+      end
+      
+      private
+      def references_self?(tags,when_id)
+        ref_self = 0
+        @bindings.each do |bb|
+          if (tags[bb.tag] == when_id)
+            ref_self += 1
+          end
+        end
+        
+        if ref_self > 0 and ref_self != @bindings.size
+          raise 'Binding to self and another pattern in the same condition is not yet supported.'
+        end
+        
+        return ref_self > 0
+      end
+      
+      def create_block(value, ref_block, basic_block)
+        if value && value.kind_of?(BindingBuilder)
+          @bindings = [value]
+          @block = ref_block
+        else
+          @block = basic_block
+        end
+      end
+    end
+    
+    class NotOperatorBuilder < AtomBuilder
+      def ==(value)
+        create_block value, lambda {|x,y| x != y}, lambda {|x| x != value}; self
+      end
+    end
+  end
+end