ruleby 0.1 → 0.2

data/lib/rulebook.rb

@@ -2,16 +2,16 @@ require 'ruleby'
 
 class Rulebook
   include Ruleby
-  def initialize(rete)
-    @rete = rete
+  def initialize(engine)
+    @engine = engine
   end
 
-  attr_reader :rete
+  attr_reader :engine
 
   def rule(name, &block)
     r = Core::Rule.new name
     yield r if block_given?
-    @rete.assert_rule r
+    @engine.assert_rule r
     r
   end
   
@@ -19,187 +19,267 @@ class Rulebook
     return Core::Action.new(&block)
   end
   
-  def pattern(&block)
-    pb = PatternBuilder.new
-    yield pb
-    return pb.condition
-  end
 end
 
-
- class PatternInternal
-    def initialize(tag, type)
-      @tag = tag
-      @type = type  
-      @atoms = []
+class WhenBuilder < Rulebook
+  def initialize()
+    @pattern_hash = Hash.new
+    @pattern_keys = []
+  end
+  
+  def method_missing(method_id, *args, &block)
+    method = method_id.to_sym
+    wi = nil
+    if @pattern_hash.key? method
+      wi = @pattern_hash[method]
+    elsif :not == method
+      @pattern_keys.push method
+      return self
+    else
+      wi = WhenInternal.new method, args[0]
+      @pattern_hash[method] = wi
+      @pattern_keys.push method
     end
-
-    def atom(tag, name, references, &block)
-      if references
-        references = [references] unless references.kind_of?(Array)
-        return Core::ReferenceAtom.new(tag, name, references, &block)
+    return wi
+  end
+  def pattern
+    operands = []
+    nt = false
+    @pattern_keys.each do |key|
+      if :not != key
+        wi = @pattern_hash[key]
+        tag = wi.tag
+        type = wi.type
+        atoms = wi.to_atoms
+        p = nil
+        if nt
+          p = Core::NotPattern.new(tag, type, atoms)
+          nt = false
+        else
+          p = Core::ObjectPattern.new(tag, type, atoms)
+        end
+        operands = operands + [p]
       else
-        return Core::PropertyAtom.new(tag, name, &block)
+        nt = true
       end
     end
-    def method_missing(method_id, *args, &block)
-      if block_given?
-        with(method_id.to_s, *args, &block) 
-      else
-        with(method_id.to_s, *args)
-      end
+    return and_pattern(operands)
+  end
+end
+
+class WhenInternal
+  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
+  
+  attr_reader :tag, :type
+  def initialize(tag, type)
+    @tag = tag
+    @type = type
+    @builder = WhenPropertyBuilder.new self
+  end
+  
+  def to_atoms
+    atoms = []
+    tags = [@tag]
+    @builder.property_hash.each_value do |wp|
+      tags.push wp.tag if wp.tag
+    end
+    @builder.property_keys.each do |key|
+      wp = @builder.property_hash[key]
+      atoms = atoms + [wp.to_atom(tags)]
     end
-    def with(property, options={}, &block)
-      tag = options[:name]      
-      tag = GeneratedTag.new if tag == options.default
-      if block_given?        
-        @atoms.push atom(tag, property, options[:references], &block)
+    return atoms
+  end
+  
+  def &
+    return self
+  end
+  
+  def method_missing(method_id, *args, &block)
+    m = method_id.to_s
+    suffix = m.to_s[-1..-1]
+    if suffix == '='
+      new_m = m[0,m.size-1]
+      if args[0].class == Array && args[0].size > 1 && args[0][1] == :% 
+        wp = @builder.create new_m do |x,y| x == y end
+        wp.references args[0][0]
+        return wp
       else
-        # QUESTION do we really want to do this?  What if someone does:
-        #   :equals => -1
-        # How do we handle a case where it is not a ReferenceAtom?  should we
-        # have a :equals_ref key too?
-#        if options[:equals] != options.default
-#          @atoms.push(atom(tag, property, [options[:equals]]) do |p,a| p==a end)
-#        elsif options[:not_equals] != options.default
-#          @atoms.push(atom(tag, property, [options[:not_equals]]) do |p,a| p!=a end)
-#        else
-          @atoms.push(atom(tag, property, nil) do |p| true end)
-#        end
+        wp = @builder.create new_m do |x| x == args[0] end
+        return wp
       end
+    else
+      wp = @builder.create(m, &block)
+      if args.size > 0 && args[0]
+        if block_given?
+          wp.references args[0]
+        else
+          wp.tag = args[0]
+        end
+      end
+      return wp       
+    end     
+  end
+end
+  
+class WhenPropertyBuilder
+  attr_reader:property_hash
+  attr_reader:property_keys
+  
+  def initialize(parent)
+    @parent = parent
+    @property_hash = Hash.new
+    @property_keys = []
+  end
+  
+  def create(method_id,&block)
+    method = method_id.to_sym
+    wp = nil
+    if @property_hash.key? method
+      wp = @property_hash[method]
+    else
+      wp = WhenProperty.new @parent, method do |p| true end
+      @property_hash[method] = wp
+      @property_keys.push method
     end
-
-    def pattern
-      @atoms = Array.new(1){@atoms} unless @atoms.kind_of?(Array)
-      return Core::ObjectPattern.new(@tag, @type, @atoms)
-    end
-   
-    def not
-      @atoms = Array.new(1){@atoms} unless @atoms.kind_of?(Array)
-      return Core::NotPattern.new(@tag, @type, @atoms)
+    if block_given?
+      wp.block = block
     end
-  end
-class PatternInternal
-  public_instance_methods.each do |m|
-    a = [:not, :pattern, :with, :method_missing, :atom, :new, :public_instance_methods, :__send__, :__id__]
-    undef_method m.to_sym unless a.include? m.to_sym
+    return wp
   end
 end
   
-  class PatternBuilder < Rulebook
-       
-    attr_reader :condition
-   
-    def initialize()
-      @condition = nil
+class WhenProperty
+  attr_accessor :block
+  def initialize(parent,name, &block)
+   @tag = nil
+   @name = name
+   @references = nil
+   @block = block
+   @parent = parent
+  end
+  attr:tag,true
+  attr:type,true
+  attr:value,true
+  
+  def &
+    return @parent
+  end
+  
+  def bind(n)
+    @tag = n
+  end
+  
+  def not=(value,ref=nil)
+    if ref && ref == :%
+      raise 'Using \'not=\' for references is not yet supported'
+      set_block do |x,y| x != y end
+      references value
+    else        
+      set_block do |s| s != value end
     end
     
-    def has(type, tag=GeneratedTag.new, &block)
-      pi = pattern_internal(tag, type)
-      yield pi if block_given? 
-      op = pi.pattern
-      if(@condition)
-        pat = [@condition, op]
-        @condition = and_pattern(pat)
-      else
-        @condition = op
-      end
-      @condition
-    end
-    def and(operands)
-      if @condition
-        p = [@condition] + operands
-        @condition = and_pattern(p)
-      else
-        @condition = and_pattern(operands)
-      end
-      @condition
+  end
+  def set_block(&block)
+    @block = block
+  end
+  private:set_block
+  
+  def references(refs)
+    @references = refs
+  end
+  
+  def to_atom(pattern_tags)
+    unless @tag
+      @tag = GeneratedTag.new
     end
-       
-    def or(operands)
-      if(@condition)
-        p = [@condition] + operands
-        @condition = or_pattern(p)
+    if @references
+      @references = [@references] unless @references.kind_of?(Array)
+      i = includes_how_many(@references, pattern_tags)
+      if i == 0
+        return Core::ReferenceAtom.new(@tag, @name, @references, &@block)
+      elsif i == @references.size
+        return Core::SelfReferenceAtom.new(@tag, @name, @references, &@block)
       else
-        @condition = or_pattern(operands)
+        raise 'Referencing self AND other patterns in the same atom is not yet supported'
       end
-      @condition
+    else  
+      return Core::PropertyAtom.new(@tag, @name, &@block)
     end
-       
-    def not(type, tag=GeneratedTag.new, &block)
-     pi = pattern_internal(tag, type)
-     yield pi if block_given? 
-     n = pi.not
-     if(@condition)
-       p = [@condition, n]
-       @condition = and_pattern(p)
-     else
-       @condition = n
-     end
+  end
+  
+  private
+  def includes_how_many(list1, list2)
+    i = 0
+    list2.each do |a|
+      i += 1 if list1.include?(a)
     end
+    return i
+  end
+end
+
+  
        
-    private
-    def pattern_internal(tag, type)
-      return PatternInternal.new(tag, type)
+private
+
+def or_pattern(operands)
+  # TODO raise exception if referenceAtoms from the right do not
+  # have the values they referenece in the left
+  # TODO raise exception if there are repeated tags?
+  left = nil
+  operands.each do |operand|
+    if left.nil?
+      left = operand
+    else           
+      right = operand
+      left = Core::OrPattern.new(left, right)
     end
+  end
+  left
+end
 
-    def or_pattern(operands)
-      # TODO raise exception if referenceAtoms from the right do not
-      # have the values they referenece in the left
-      # TODO raise exception if there are repeated tags?
-      left = nil
-      operands.each do |operand|
-        if left.nil?
-          left = operand
-        else           
-          right = operand
-          left = Core::OrPattern.new(left, right)
-        end
-      end
-      left
+def and_pattern(operands)
+  # TODO raise exception if referenceAtoms from the right do not
+  # have the values they referenece in the left
+  # TODO raise exception if there are repeated tags?
+  left = nil
+  operands.each do |operand|
+    if left.nil?
+      left = operand
+    else           
+      right = operand
+      left = Core::AndPattern.new(left, right)
     end
+  end
+  left
+end  
 
-    def and_pattern(operands)
-      # TODO raise exception if referenceAtoms from the right do not
-      # have the values they referenece in the left
-      # TODO raise exception if there are repeated tags?
-      left = nil
-      operands.each do |operand|
-        if left.nil?
-          left = operand
-        else           
-          right = operand
-          left = Core::AndPattern.new(left, right)
-        end
-      end
-      left
-    end  
+class GeneratedTag
+
+  # this counter is incremented for each UniqueTag created, and is
+  # appended to the end of the unique_seed in order to create a 
+  # string that is unique for each instance of this class.
+  @@tag_counter = 0
+  
+  # every generated tag will be prefixed with this string
+  @@unique_seed = 'unique_seed'
+
+  def initialize()
+    @@tag_counter += 1
+    @tag = @@unique_seed + @@tag_counter.to_s
   end
   
-  class GeneratedTag
+  attr_reader:tag_counter
+  attr_reader:unique_seed
+  attr_reader:tag
   
-    # this counter is incremented for each UniqueTag created, and is
-    # appended to the end of the unique_seed in order to create a 
-    # string that is unique for each instance of this class.
-    @@tag_counter = 0
-    
-    # every generated tag will be prefixed with this string
-    @@unique_seed = 'unique_seed'
+  def ==(ut)
+    return ut && ut.kind_of?(GeneratedTag) && @tag == ut.tag
+  end
   
-    def initialize()
-      @@tag_counter += 1
-      @tag = @@unique_seed + @@tag_counter.to_s
-    end
-    
-    attr_reader:tag_counter
-    attr_reader:unique_seed
-    attr_reader:tag
-    
-    def ==(ut)
-      return ut && ut.kind_of?(GeneratedTag) && @tag == ut.tag
-    end
-    
-    def to_s
-      return @tag.to_s
-    end
+  def to_s
+    return @tag.to_s
   end
+end

data/lib/ruleby.rb

@@ -6,24 +6,4 @@ module Ruleby
     yield e if block_given?
     return e
   end
-  def assert(rete,object,&block)
-    fact(rete,object,:plus,&block)
-  end
-  
-  def retract(rete,object,&block)
-    fact(rete,object,:minus,&block)
-  end
-  
-  def modify(rete,object,&block)
-    retract(rete,object,&block)
-    assert(rete,object,&block)
-  end
-  
-  private 
-  def fact(rete, object, sign=:plus, &block)
-    f = Core::Fact.new object, sign
-    yield f if block_given?
-    rete.assert_fact f
-    f
-  end
 end