ruleby 0.8.b9 → 0.8

data/lib/core/atoms.rb

@@ -14,17 +14,17 @@ module Ruleby
   module Core
   
   class Atom     
-    attr_reader :tag, :proc, :method, :deftemplate
+    attr_reader :tag, :proc, :slot, :template
     
-    def initialize(tag, method, deftemplate, &block)
+    def initialize(tag, slot, template, block)
       @tag = tag
-      @method = method
-      @deftemplate = deftemplate
-      @proc = Proc.new(&block) if block_given?
+      @slot = slot
+      @template = template
+      @proc = block
     end    
     
     def to_s
-      return "#{self.class},#{@tag},#{@method},#{@deftemplate}"
+      "#{self.class},#{@tag},#{@slot},#{@template}"
     end
   end
   
@@ -34,16 +34,25 @@ module Ruleby
   #   a.person{ |p| p.is_a? Person }
   # 
   # So there are no references to other atoms.
-  class PropertyAtom < Atom    
+  class PropertyAtom < Atom
+
+    attr_reader :value
+
+    def initialize(tag, slot, template, value, block)
+      super(tag,slot,template, block)
+      @value = value
+    end
+
     def ==(atom)      
-      return shareable?(atom) && @tag == atom.tag
+      shareable?(atom) && @tag == atom.tag
     end   
     
     def shareable?(atom)
-      return PropertyAtom === atom && 
-             @method == atom.method && 
-             @deftemplate == atom.deftemplate && 
-             @proc == atom.proc 
+      PropertyAtom === atom &&
+             @slot == atom.slot &&
+             @template == atom.template &&
+             @proc == atom.proc &&
+             @value == atom.value
     end
   end
 
@@ -53,30 +62,21 @@ module Ruleby
 
     def initialize(tag, template, arguments, block)
       @tag = tag
-      @method = nil
-      @deftemplate = template
+      @slot = nil
+      @template = template
       @arguments = arguments
       @proc = block
     end
 
     def shareable?(atom)
       FunctionAtom === atom &&
-             @deftemplate == atom.deftemplate &&
+             @template == atom.template &&
              @arguments == atom.arguments &&
              @proc == atom.proc
     end
 
     def to_s
-      return "#{self.class},#{@deftemplate},#{@arguments.inspect}"
-    end
-  end
-
-  # TODO use this
-  class BlockAtom < PropertyAtom
-    def shareable?(atom)
-      return super &&
-             BlockAtom === atom &&              
-             @proc == atom.proc 
+      "#{self.class},#{@template},#{@arguments.inspect}"
     end
   end
   
@@ -87,16 +87,16 @@ module Ruleby
   # 
   # So there are no references to other atoms.
   class EqualsAtom < PropertyAtom
-    attr_reader :value
-    def initialize(tag, method, deftemplate, value)
-      super(tag,method,deftemplate)
-      @value = value
+    EQUAL_PROC  = lambda {|x, y| x == y}
+
+    def initialize(tag, slot, template, value)
+      super(tag,slot,template, value, EQUAL_PROC)
     end
-    
+
     def shareable?(atom)
-      return EqualsAtom === atom && 
-             @method == atom.method && 
-             @deftemplate == atom.deftemplate 
+      EqualsAtom === atom &&
+             @slot == atom.slot &&
+             @template == atom.template
     end
   end
   
@@ -105,17 +105,20 @@ module Ruleby
   #   'For each Person as :p'
   # 
   # It is only used at the start of a pattern.
-  class HeadAtom < Atom
-    def initialize(tag, deftemplate)   
-      if deftemplate.mode == :equals
-        super tag, :class, deftemplate do |t| t == deftemplate.clazz end
-      elsif deftemplate.mode == :inherits
-        super tag, :class, deftemplate do |t| t === deftemplate.clazz end
+  class HeadAtom < PropertyAtom
+    HEAD_EQUAL_PROC  = lambda {|t, c| t == c}
+    HEAD_INHERITS_PROC  = lambda {|t, c| t === c}
+
+    def initialize(tag, template)
+      if template.mode == :equals
+        super tag, :class, template, template.clazz, HEAD_EQUAL_PROC
+      elsif template.mode == :inherits
+        super tag, :class, template, template.clazz, HEAD_INHERITS_PROC
       end
     end
     
     def shareable?(atom)
-      return HeadAtom === atom && @deftemplate == atom.deftemplate
+      HeadAtom === atom && @template == atom.template
     end
   end
   
@@ -128,8 +131,8 @@ module Ruleby
   class ReferenceAtom < Atom  
     attr_reader :vars
     
-    def initialize(tag, method, vars, deftemplate, &block) 
-      super(tag, method, deftemplate, &block)
+    def initialize(tag, slot, vars, template, block)
+      super(tag, slot, template, block)
       @vars = vars # list of referenced variable names
     end    
     
@@ -138,21 +141,21 @@ module Ruleby
     end
     
     def ==(atom)      
-      return ReferenceAtom === atom && 
+      ReferenceAtom === atom &&
              @proc == atom.proc && 
              @tag == atom.tag && 
              @vars == atom.vars && 
-             @deftemplate == atom.deftemplate
+             @template == atom.template
     end
     
     def to_s
-      return super + ", vars=#{vars.join(',')}"
+      super + ", vars=#{vars.join(',')}"
     end
   end
   
   # This is an atom that references another atom that is in the same pattern.
   # Note that in a SelfReferenceAtom, the 'vars' argument must be a list of the
-  # *methods* that this atom references (not the variable names)!
+  # *slots* that this atom references (not the variable names)!
   class SelfReferenceAtom < ReferenceAtom
   end
   
@@ -179,4 +182,4 @@ module Ruleby
   end
 
 end
-end
+end

data/lib/core/nodes.rb

@@ -222,27 +222,23 @@ module Ruleby
         end
         @atom_nodes.each {|n| return n if n.shareable? node}
         @atom_nodes.push node
-        return node
+        node
       end
       
       def create_self_reference_node(atom)   
         node = SelfReferenceNode.new(@bucket, atom)
         @atom_nodes.push node
-        return node
+        node
       end
       
       def create_reference_node(atom)      
         node = ReferenceNode.new(@bucket, atom)
         @atom_nodes.push node
-        return node
+        node
       end
       
       def create_adapter_node(side)
-        if side == :left
-          return LeftAdapterNode.new(@bucket)
-        else
-          return RightAdapterNode.new(@bucket)
-        end
+        side == :left ? LeftAdapterNode.new(@bucket) : RightAdapterNode.new(@bucket)
       end
       
       # This method is used to update each TypeNode based on the facts in 
@@ -294,7 +290,7 @@ module Ruleby
           end
         end
       end 
-      return true
+      true
     end
   end
   
@@ -370,15 +366,15 @@ module Ruleby
     end
     
     def ==(node)
-      return AtomNode === node && @atom == node.atom
+      AtomNode === node && @atom == node.atom
     end
     
     def shareable?(node)
-      return @atom.shareable?(node.atom)
+      @atom.shareable?(node.atom)
     end
     
     def to_s
-      super + " - #{@atom.method}"
+      super + " - #{@atom.slot}"
     end
   end
   
@@ -406,7 +402,7 @@ module Ruleby
     end
     
     def assert(assertable)
-      k = assertable.fact.object.send(@atom.method)
+      k = assertable.fact.object.send(@atom.slot)
 
       # TODOwe need to do this for ALL tags if this node is shared
       assertable.add_tag(@atom.tag, k)
@@ -424,7 +420,7 @@ module Ruleby
   # is matched exactly (ignoring inheritance).
   class TypeNode < HashedNode    
     def hash_by(atom) 
-      atom.deftemplate.clazz
+      atom.template.clazz
     end
 
     def retract(fact)
@@ -432,7 +428,7 @@ module Ruleby
     end
 
     def assert(fact)
-      k = fact.object.send(@atom.method)
+      k = fact.object.send(@atom.slot)
       # TODO we should create the Assertion object here, not in propogate
       propagate_assert fact, (@values[k] ? @values[k] : {})
     rescue NoMethodError => e
@@ -468,8 +464,8 @@ module Ruleby
   class PropertyNode < AtomNode
     def assert(assertable)
       begin
-        val = assertable.fact.object.send(@atom.method)
-        assertable.add_tag(@atom.tag, val)
+        v = assertable.fact.object.send(@atom.slot)
+        assertable.add_tag(@atom.tag, v)
       rescue NoMethodError => e
         @bucket.add_error Error.new(:no_method, :warn, {
             :object => assertable.fact.object.to_s,
@@ -479,12 +475,16 @@ module Ruleby
         return
       end
       begin
-        super if @atom.proc.call(val)
+        if @atom.proc.arity == 1
+          super if @atom.proc.call(v)
+        else
+          super if @atom.proc.call(v, @atom.value)
+        end
       rescue Exception => e
         @bucket.add_error Error.new(:proc_call, :error, {
             :object => assertable.fact.object.to_s,
-            :method => @atom.method,
-            :value => val.to_s,
+            :method => @atom.slot,
+            :value => v.to_s,
             :message => e.message
         })
       end
@@ -500,7 +500,7 @@ module Ruleby
     end   
   end  
   
-  # This node class is used for matching properties of a fact.
+  # This node class is used conditions that are simply a function, which returns true or false.
   class FunctionNode < AtomNode
     def assert(assertable)
       begin
@@ -522,7 +522,7 @@ module Ruleby
   # invoked by the two input node.
   class ReferenceNode < AtomNode    
     def match(left_context,right_fact)
-      val = right_fact.object.send(@atom.method)  
+      val = right_fact.object.send(@atom.slot)
       args = [val]            
       match = left_context.match
       @atom.vars.each do |var|
@@ -558,7 +558,7 @@ module Ruleby
     end
     
     def match(fact)
-      args = [fact.object.send(@atom.method)]
+      args = [fact.object.send(@atom.slot)]
       @atom.vars.each do |var|
         args.push fact.object.send(var)   
       end   
@@ -596,11 +596,11 @@ module Ruleby
         if atom == @pattern.head
           # TODO once we fix up TypeNode, we won't need this
           mr[atom.tag] = fact.object
-        elsif !mr.key?(atom.tag) and atom.method
+        elsif !mr.key?(atom.tag) and atom.slot
           # this is a big hack for the sake of performance.  should really do whats described below
           unless atom.tag.is_a?(GeneratedTag)
             # TODO it should be possible to get rid of this, and just capture it in the Nodes above
-            mr[atom.tag] = fact.object.send(atom.method)
+            mr[atom.tag] = fact.object.send(atom.slot)
           end
         end
       end
@@ -1002,4 +1002,4 @@ module Ruleby
   end
 
   end
-end
+end

data/lib/dsl/ferrari.rb

@@ -301,7 +301,7 @@ module Ruleby
       public_instance_methods.each do |m|
         # maybe we shouldn't be undefing object_id.  What are the implications?  Can we make object_id a
         # pass through to the underlying object's object_id?
-        a = [:method_missing, :new, :public_instance_methods, :__send__, :__id__]
+        a = [:method_missing, :new, :public_instance_methods, :__send__, :__id__, :object_id]
         undef_method m.to_sym unless a.include? m.to_sym
       end
     
@@ -316,7 +316,7 @@ module Ruleby
           puts args.class.to_s + ' --- ' + args.to_s
           raise 'Arguments not supported for short-hand conditions' 
         end
-        return ab
+        ab
       end
     end
 
@@ -361,46 +361,59 @@ module Ruleby
     
     class AtomBuilder
       attr_accessor :tag, :name, :bindings, :deftemplate, :block
-      
+
+      EQ_PROC = lambda {|x,y| x and x == y}
+      GT_PROC = lambda {|x,y| x and x > y}
+      LT_PROC = lambda {|x,y| x and x < y}
+      MATCH_PROC = lambda {|x,y| x and x =~ y}
+      LTE_PROC = lambda {|x,y| x and x <= y}
+      GTE_PROC = lambda {|x,y| x and x >= y}
+      TRUE_PROC = lambda {|x| true}
+
       def initialize(method_id)
         @name = method_id
         @deftemplate = nil
         @tag = GeneratedTag.new
         @bindings = []
-        @block = lambda {|x| true}
+        @block = TRUE_PROC
         @child_atom_builders = []
       end
       
       def method_missing(method_id, *args, &block)
         if method_id == :not
-          return NotOperatorBuilder.new(@name)
+          NotOperatorBuilder.new(@name)
         end
       end
       
       def ==(value)
         @atom_type = :equals
-        @value = value
-        create_block value, lambda {|x,y| x == y}, lambda {|x| x == value}; self
+        create_block value, EQ_PROC
+        self
       end
       
       def >(value)
-        create_block value, lambda {|x,y| x > y}, lambda {|x| x > value}; self
+        create_block value, GT_PROC
+        self
       end
       
       def <(value)
-        create_block value, lambda {|x,y| x < y}, lambda {|x| x < value}; self
+        create_block value, LT_PROC
+        self
       end
       
       def =~(value)
-        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
+        create_block value, MATCH_PROC
+        self
       end
       
       def <=(value)
-        create_block value, lambda {|x,y| x <= y}, lambda {|x| x <= value}; self
+        create_block value, LTE_PROC
+        self
       end
       
       def >=(value)
-        create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= value}; self
+        create_block value, GTE_PROC
+        self
       end 
       
       def build_atoms(tags,methods,when_id)
@@ -414,16 +427,16 @@ module Ruleby
           if @atom_type == :equals 
             return atoms << Core::EqualsAtom.new(@tag, @name, @deftemplate, @value)
           else
-            return atoms << Core::PropertyAtom.new(@tag, @name, @deftemplate, &@block)
+            return atoms << Core::PropertyAtom.new(@tag, @name, @deftemplate, @value, @block)
           end
         end
         
         if references_self?(tags,when_id)
           bind_methods = @bindings.collect{ |bb| methods[bb.tag] }
-          atoms << Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@deftemplate,&@block)
+          atoms << Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@deftemplate,@block)
         else
           bind_tags = @bindings.collect{ |bb| bb.tag }
-          atoms << Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,&@block)
+          atoms << Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,@block)
         end
       end
       
@@ -440,26 +453,27 @@ module Ruleby
           raise 'Binding to self and another pattern in the same condition is not yet supported.'
         end
         
-        return ref_self > 0
+        ref_self > 0
       end
       
-      def create_block(value, ref_block, basic_block)
+      def create_block(value, block)
+        @block = block
         if value && value.kind_of?(BindingBuilder)
           @bindings = [value]
-          @block = ref_block
         elsif value && value.kind_of?(AtomBuilder)
           @child_atom_builders << value
           @bindings = [BindingBuilder.new(value.tag)]
-          @block = ref_block
         else
-          @block = basic_block
+          @value = value
         end
       end
     end
     
     class NotOperatorBuilder < AtomBuilder
+      NOT_PROC = lambda {|x,y| x != y}
       def ==(value)
-        create_block value, lambda {|x,y| x != y}, lambda {|x| x != value}; self
+        create_block value, NOT_PROC
+        self
       end
     end
 

data/lib/rulebook.rb

@@ -12,8 +12,6 @@
 require 'ruleby'
 require 'rule_helper'
 require 'dsl/ferrari'
-require 'dsl/letigre'
-require 'dsl/steel'
 
 module Ruleby
   class Rulebook
@@ -36,15 +34,10 @@ module Ruleby
       @engine.modify fact
     end
     def rule(*args, &block)
-      unless args.empty?
-        name = args[0].kind_of?(Symbol) ? args.shift : GeneratedTag.new
-      end
-    
       if args.empty?
-        # use steel DSL
-        r = Steel::RulebookHelper.new @engine
-        r.rule name, &block
+        raise 'Must provide arguments to rule'
       else
+        name = args[0].kind_of?(Symbol) ? args.shift : GeneratedTag.new
         i = args[0].kind_of?(Hash) ? 1 : 0
         if [Array, Ruleby::Ferrari::OrBuilder, Ruleby::Ferrari::AndBuilder].include? args[i].class
           # use ferrari DSL

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: ruleby
 version: !ruby/object:Gem::Version 
-  prerelease: 4
-  version: 0.8.b9
+  prerelease: 
+  version: "0.8"
 platform: ruby
 authors: 
   - Joe Kutner
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-03 00:00:00 -05:00
+date: 2011-06-16 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -38,8 +38,6 @@ files:
   - lib/core/patterns.rb
   - lib/core/utils.rb
   - lib/dsl/ferrari.rb
-  - lib/dsl/letigre.rb
-  - lib/dsl/steel.rb
   - tests/test.rb
 has_rdoc: true
 homepage: http://ruleby.org
@@ -59,9 +57,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.1
+        version: "0"
 requirements: []
 
 rubyforge_project: ruleby

data/lib/dsl/letigre.rb

@@ -1,238 +0,0 @@
-# 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 LeTigre
-    class RulebookHelper
-      
-      def initialize(engine, rulebook)
-        @rulebook = rulebook
-        @engine = engine
-      end
-    
-      attr_reader :engine
-    
-      def rule(name, *args, &then_block)
-        if args.empty?
-          raise 'No conditions supplied.'
-        end
-      
-        options = args[0].kind_of?(Hash) ? args.shift : {}
-      
-        pb = PatternParser.new @rulebook
-        pattern = pb.parse args
-    
-        rb = RuleBuilder.new name
-        
-        rb.when(pattern)
-        rb.then(&then_block)
-        rb.priority = options[:priority] if options[:priority]
-        
-        @engine.assert_rule rb.build_rule
-      end
-    
-    end
-    
-    class RuleBuilder
-    
-      def initialize(name, pattern=nil, action=nil, priority=0) 
-        @name = name
-        @pattern = pattern
-        @action = action  
-        @priority = priority    
-        
-        @tags = {}
-        @when_counter = 0
-      end   
-        
-      def when(pattern)
-        @pattern = pattern
-      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 PatternParser
-      @@head_error = 'Invalid type specification.'      
-      @@method_error = "No #method in expression: "
-    
-      @@base_re  = /(For each|\w*\s*exists\??|not\??)(.*)/
-      @@mode_re  = /( (is a|kind of|instance of) )(.*)/
-      @@where_re = /(.*)where (.*)/      
-      @@head_re  = /(\w*)( as :(.*))?/
-      
-      @@method_re = /#((\w|\d|\_)*)\??/
-      @@bind_re   = /#:(\w*|\d*\_*)*/
-      @@and_re    = /#&&/
-      @@tag_re    = /(.*) as :(.*)/
-      
-      def initialize(rulebook)
-        @rulebook = rulebook
-      end
-      
-      def parse(lhs_strs)
-        pattern = nil
-        lhs_strs.each do |lhs|  
-          # match the quantifier
-          if lhs =~ @@base_re
-            base = $1
-            tail = $2
-          else
-            base = 'For each'
-            tail = lhs
-          end
-          
-          raise 'The \'exists\' quantifier is not yet supported.' if base =~ /exists/
-          
-          if tail =~ @@mode_re
-            mode = :inherits
-            tail = $3
-          else
-            mode = :equals           
-          end
-          
-          # check if there is a where clause
-          if tail =~ @@where_re
-            head = $1.strip
-            tail = $2
-          else
-            head = tail.strip
-            tail = nil
-          end
-          
-          # match the class type and tag
-          if head != ''
-            head =~ @@head_re            
-            clazz = @rulebook.__eval__ $1
-            tag = $3 ? $3.to_sym : GeneratedTag.new 
-          else
-            clazz = Object
-            tag = GeneratedTag.new
-            mode = :inherits
-          end
-          
-          deftemplate = Core::Template.new clazz, mode
-          head = Core::HeadAtom.new tag, deftemplate
-
-          atoms = []      
-          atom_strs = tail ? tail.split(@@and_re) : []
-          atom_strs.each do |a|
-            # BUG we also need to pass in the head_tag with atoms!
-            atoms.push parse_atom(a, deftemplate, atoms)
-          end        
-                    
-          if base =~ /not\??/
-            p = mode==:inherits ? Core::NotInheritsPattern.new(head, atoms) :
-                                  Core::NotPattern.new(head, atoms) 
-          else 
-            p = mode==:inherits ? Core::InheritsPattern.new(head, atoms) :
-                                  Core::ObjectPattern.new(head, atoms) 
-          end
-                              
-          pattern = pattern ? Core::AndPattern.new(pattern, p) : p
-        end
-        return pattern
-      end
-      
-      private 
-      def parse_atom(str, deftemplate, atoms)
-        expression, tag = nil, nil
-        if str =~ @@tag_re 
-          expression, tag = $1, $2.strip.to_sym
-        else
-          expression, tag = str, GeneratedTag.new
-        end
-        
-        bindings = []
-        uniq_binds = []
-        expression.scan(@@bind_re).each do |b|
-          # HACK how can we create a truely unique variable name?
-          uniq_bind = "ruleby_unique_variable_name_#{b[0]}"
-          uniq_binds.push uniq_bind
-          expression.sub!(/#:#{b[0]}/, uniq_bind)
-          bindings.push b[0].strip.to_sym
-        end      
-        
-        raise @@method_error + expression unless expression =~ @@method_re
-        method = $1
-        expression.gsub!(/##{method}/, method)      
-        expression = "true" if expression.strip == method
-        
-        proc = "lambda {|#{method}"
-          
-        uniq_binds.each do |b|
-          # TODO make sure 'b' is not equal to 'method' or other b's
-          proc += ",#{b}"
-        end
-        
-        proc += "| #{expression} }"
-        
-        block = eval proc
-    
-        if bindings.empty? 
-          return Core::PropertyAtom.new(tag, method, deftemplate, &block)
-        elsif references_self?(bindings, atoms)
-          bound_methods = resolve_bindings(bindings, atoms)
-          return Core::SelfReferenceAtom.new(tag, method, bound_methods, deftemplate, &block)
-        else
-          return Core::ReferenceAtom.new(tag, method, bindings, deftemplate, &block)
-        end
-      end
-      
-      def references_self?(bindings, atoms)
-        ref_self = 0
-        bindings.each do |b|
-          atoms.each do |a|
-            if (a.tag == b)
-              ref_self += 1
-            end
-          end
-        end
-        
-        if ref_self > 0 and ref_self != bindings.size
-          raise 'Binding to self and another pattern in the same expression is not yet supported.'
-        end
-        
-        return ref_self > 0
-      end
-      
-      def resolve_bindings(bindings, atoms)
-        bound_methods = []
-        bindings.each do |b|
-          atoms.each do |a|
-            if a.tag == b
-              bound_methods.push a.method
-            end
-          end
-        end
-        return bound_methods
-      end
-      
-    end 
-  end
-end

data/lib/dsl/steel.rb

@@ -1,314 +0,0 @@
-# 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: Matt Smith
-#
-
-module Ruleby
-  module Steel
-    class RulebookHelper
-
-      include Ruleby
-      def initialize(engine)
-        raise 'This DSL is deprecated'
-        @engine = engine
-      end
-    
-      attr_reader :engine
-    
-      def rule(name, &block)
-        r = Steel::RuleBuilder.new name
-        yield r if block_given?
-        @engine.assert_rule r.build_rule
-        r
-      end
-     
-    end
-    
-    class RuleBuilder
-    
-      def initialize(name, pattern=nil, action=nil, priority=0) 
-        @name = name
-        @pattern = pattern
-        @action = action  
-        @priority = priority    
-      end   
-        
-      def when(&block)
-        wb = WhenBuilder.new
-        yield wb
-        @pattern = wb.pattern
-      end
-      
-      def then(&block)
-        @action = Core::Action.new(&block)  
-        @action.name = @name
-        @action.priority = @priority
-      end
-      
-      def when=(pattern)
-        @pattern = pattern
-      end
-      
-      def then=(action)
-        @action = action
-        @action.name = @name
-        @action.priority = @priority
-      end  
-          
-      def priority
-        return @priority
-      end
-      
-      def priority=(p)
-        @priority = p
-        @action.priority = @priority
-      end 
-        
-      def build_rule
-        r = Ruleby::Core::Rule.new @name, @pattern, @action, @priority
-      end
-    end
-    
-    class WhenBuilder #< RulebookHelper
-      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
-        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 = Ruleby::Core::NotPattern.new(tag, type, atoms)
-              nt = false
-            else
-              p = Ruleby::Core::ObjectPattern.new(tag, type, atoms)
-            end
-            operands = operands + [p]
-          else
-            nt = true
-          end
-        end
-        return and_pattern(operands)
-      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 = Ruleby::Core::AndPattern.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 = Ruleby::Core::OrPattern.new(left, right)
-          end
-        end
-        left
-      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 => :class}
-        @builder.property_hash.each_value do |wp|
-          tags[wp.tag] = wp.name if wp.tag
-        end
-        @builder.property_keys.each do |key|
-          wp = @builder.property_hash[key]
-          atoms = atoms + [wp.to_atom(tags)]
-        end
-        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
-            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
-        if block_given?
-          wp.block = block
-        end
-        return wp
-      end
-    end
-      
-    class WhenProperty
-      
-      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
-      attr_reader:name
-      attr_accessor:block
-      
-      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
-        
-      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
-        if @references
-          @references = [@references] unless @references.kind_of?(Array)
-          i = includes_how_many(@references, pattern_tags.keys)
-          if i == 0
-            return Ruleby::Core::ReferenceAtom.new(@tag, @name, @references, @parent.type, &@block)
-          elsif i == @references.size
-            refs = @references.collect{|r| pattern_tags[r] }
-            return Ruleby::Core::SelfReferenceAtom.new(@tag, @name, refs, @parent.type, &@block)
-          else
-            raise 'Referencing self AND other patterns in the same atom is not yet supported'
-          end
-        else  
-          return Ruleby::Core::PropertyAtom.new(@tag, @name, @parent.type, &@block)
-        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
-
-  end
-end