ruleby 0.3 → 0.4

data/lib/core/patterns.rb

@@ -19,29 +19,27 @@ module Ruleby
   # object. It contains a list of 'atoms' that represent the properties of
   # the class that we are looking for.
   class ObjectPattern < Pattern
-    
-    attr_reader :head
     attr_reader :atoms
     
-    # 'deftemplate' is a class type
-    def initialize(tag, deftemplate, atoms)
-      init_vars tag, deftemplate, atoms   
+    def initialize(head, atoms)
+      @atoms = [head] + atoms     
     end
     
-    def init_vars(tag,deftemplate,atoms)
-      @head = TypeAtom.new tag, deftemplate 
-      @atoms = [@head] + atoms              
+    def head
+      @atoms[0]
     end      
     
     def ==(pattern)
-      atoms = pattern.atoms
-      if(@atoms.size == atoms.size)
-        (0..@atoms.size).each do |i|
-          if !(@atoms[i] == atoms[i])
-            return false
+      if pattern.class == self.class
+        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 true
       end
       return false
     end
@@ -51,13 +49,16 @@ module Ruleby
     end
   end
   
+  class InheritsPattern < ObjectPattern
+  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 ==(pattern)
-      return pattern.kind_of?(NotPattern) && super==(pattern)
-    end
+  end
+  
+  class NotInheritsPattern < InheritsPattern
   end
   
   # A composite pattern represents a logical conjunction of two patterns.  The
@@ -99,6 +100,8 @@ module Ruleby
 
   end
 
-  
+  class PatternFactory
+    
+  end
 end
 end

data/lib/dsl/ferrari.rb

@@ -44,47 +44,52 @@ module Ruleby
         @name = name
         @pattern = pattern
         @action = action  
-        @priority = priority    
+        @priority = priority            
         
         @tags = {}
         @methods = {}
         @when_counter = 0
       end   
         
-      def when(*args)
-        clazz = args.shift
+      def when(*args)      
+        clazz = AtomBuilder === args[0] ? nil : 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.'
+        mode = :equals
+        while clazz.is_a? Symbol          
+          if clazz == :not || clazz == :~
+            is_not = true
+          elsif clazz == :is_a? || clazz == :kind_of? || clazz == :instance_of?
+            mode = :inherits
+          elsif clazz == :exists?
+            raise 'The \'exists\' quantifier is not yet supported.'
+          end
+          clazz = args.empty? ? nil : args.shift 
+        end
+        
+        if clazz == nil
+          clazz = Object
+          mode = :inherits
         end
         
-        head_tag = nil
+        deftemplate = Core::DefTemplate.new clazz, mode        
         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
+        htag = Symbol === args[0] ? args.shift : GeneratedTag.new
+        head = Core::HeadAtom.new htag, deftemplate
+        @tags[htag] = @when_counter
         
         args.each do |arg|
           if arg.kind_of? Hash
             arg.each do |ab,tag|
               ab.tag = tag
-              ab.clazz = clazz
+              ab.deftemplate = deftemplate
               @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
+            arg.deftemplate = deftemplate
             @methods[arg.tag] = arg.name
             atoms.push arg.build_atom(@tags, @methods, @when_counter)
           elsif arg == false
@@ -94,8 +99,13 @@ module Ruleby
           end
         end  
         
-        p = is_not ? Core::NotPattern.new(head_tag, clazz, atoms) : 
-                     Core::ObjectPattern.new(head_tag, clazz, atoms)
+        if is_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
         
         return nil
@@ -171,11 +181,11 @@ module Ruleby
     end
     
     class AtomBuilder
-      attr_accessor :tag, :name, :bindings, :clazz, :block
+      attr_accessor :tag, :name, :bindings, :deftemplate, :block
       
       def initialize(name)   
         @name = name
-        @clazz = nil
+        @deftemplate = nil
         @tag = nil
         @bindings = []
         @block = lambda {|x| true}
@@ -188,6 +198,8 @@ module Ruleby
       end
       
       def ==(value)
+        @atom_type = :equals
+        @value = value
         create_block value, lambda {|x,y| x == y}, lambda {|x| x == value}; self
       end
       
@@ -209,22 +221,27 @@ module Ruleby
       
       def >=(value)
         create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= value}; self
-      end  
+      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?
+      def =~(value)
+        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
+      end 
+      
+      def build_atom(tags,methods,when_id)               
+        if @bindings.empty?
+          if @atom_type == :equals 
+            return Core::EqualsAtom.new(@tag, @name, @deftemplate, @value) 
+          else
+            return Core::PropertyAtom.new(@tag, @name, @deftemplate, &@block) 
+          end
+        end
         
         if references_self?(tags,when_id)
           bind_methods = @bindings.collect{ |bb| methods[bb.tag] }
-          Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@clazz,&@block)
+          Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@deftemplate,&@block)
         else
           bind_tags = @bindings.collect{ |bb| bb.tag }
-          Core::ReferenceAtom.new(@tag,@name,bind_tags,@clazz,&@block)
+          Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,&@block)
         end
       end
       

data/lib/dsl/letigre.rb

@@ -13,7 +13,8 @@ module Ruleby
   module LeTigre
     class RulebookHelper
       
-      def initialize(engine)
+      def initialize(engine, rulebook)
+        @rulebook = rulebook
         @engine = engine
       end
     
@@ -26,7 +27,7 @@ module Ruleby
       
         options = args[0].kind_of?(Hash) ? args.shift : {}
       
-        pb = PatternParser.new 
+        pb = PatternParser.new @rulebook
         pattern = pb.parse args
     
         rb = RuleBuilder.new name
@@ -81,14 +82,18 @@ module Ruleby
       @@method_error = "No #method in expression: "
     
       @@base_re  = /(For each|\w*\s*exists\??|not\??)(.*)/
-      @@where_re = /(.*) where (.*)/      
+      @@mode_re  = /( (is a|kind of|instance of) )(.*)/
+      @@where_re = /(.*)where (.*)/      
       @@head_re  = /(\w*)( as :(.*))?/
       
-      @@method_re = /#(\w*|\d*\_*)*\??/
+      @@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
@@ -104,6 +109,13 @@ module Ruleby
           
           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
@@ -114,27 +126,41 @@ module Ruleby
           end
           
           # match the class type and tag
-          raise @@head_error unless head =~ @@head_re
-          clazz = eval $1
-          tag = $3 ? $3.to_sym : GeneratedTag.new 
+          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::DefTemplate.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, clazz, atoms)
+            atoms.push parse_atom(a, deftemplate, atoms)
           end        
-    
-          p = (base == 'not?' || base == 'not') ? 
-                              Core::NotPattern.new(tag, clazz, atoms) :
-                              Core::ObjectPattern.new(tag, clazz, atoms) 
+                    
+          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, clazz, atoms)
+      def parse_atom(str, deftemplate, atoms)
         expression, tag = nil, nil
         if str =~ @@tag_re 
           expression, tag = $1, $2.strip.to_sym
@@ -169,12 +195,12 @@ module Ruleby
         block = eval proc
     
         if bindings.empty? 
-          return Core::PropertyAtom.new(tag, method, clazz, &block)
+          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, clazz, &block)
+          return Core::SelfReferenceAtom.new(tag, method, bound_methods, deftemplate, &block)
         else
-          return Core::ReferenceAtom.new(tag, method, bindings, clazz, &block)
+          return Core::ReferenceAtom.new(tag, method, bindings, deftemplate, &block)
         end
       end
       
@@ -200,7 +226,7 @@ module Ruleby
         bindings.each do |b|
           atoms.each do |a|
             if a.tag == b
-              bound_methods.push a.name
+              bound_methods.push a.method
             end
           end
         end

data/lib/dsl/steel.rb

@@ -15,6 +15,7 @@ module Ruleby
 
       include Ruleby
       def initialize(engine)
+        raise 'This DSL is deprecated'
         @engine = engine
       end
     

data/lib/dsl/yaml_dsl.rb

@@ -0,0 +1,23 @@
+
+require 'ruleby'
+require 'dsl/letigre'
+module Ruleby
+  module YamlDsl
+    require 'yaml'
+    def self.load_rules(rules_yaml, engine)
+      ry = YAML::load(rules_yaml)
+      ry.each do |k,v|
+        if k =~ /_rule/
+          wh = v['when']
+          wh.gsub!('@', '#')
+          wh = wh.split(',')
+          th = v['then']
+          priority = v['priority']
+          th = "context engine -> #{th}"       
+          r = LeTigre::RulebookHelper.new engine
+          r.rule k, { :priority => priority }, *wh, &th.to_proc
+        end
+      end
+    end
+  end
+end

data/lib/rulebook.rb

@@ -17,12 +17,23 @@ require 'dsl/steel'
 module Ruleby
   class Rulebook
     include Ruleby
-    def initialize(engine)
+    def initialize(engine, session={})
       @engine = engine
+      @session = session
     end
   
     attr_reader :engine
-  
+    attr_reader :session
+    
+    def assert(fact)
+      @engine.assert fact
+    end
+    def retract(fact)
+      @engine.retract fact
+    end
+    def modify(fact)
+      @engine.modify fact
+    end
     def rule(*args, &block)
       unless args.empty?
         name = args[0].kind_of?(Symbol) ? args.shift : GeneratedTag.new
@@ -40,7 +51,7 @@ module Ruleby
           r.rule name, *args, &block
         elsif args[i].kind_of? String
           # use letigre DSL
-          r = LeTigre::RulebookHelper.new @engine
+          r = LeTigre::RulebookHelper.new @engine, self
           r.rule name, *args, &block
         else
           raise 'Rule format not recognized.'
@@ -71,6 +82,10 @@ module Ruleby
     def condition(&block)
       return lambda(&block)
     end
+    
+    def __eval__(x)
+      eval(x)
+    end
   end  
   
   class GeneratedTag  

data/lib/ruleby.rb

@@ -19,4 +19,41 @@ module Ruleby
     yield e if block_given?
     return e
   end
+end
+
+class String
+  unless ''.respond_to?(:to_proc)
+    def to_proc &block
+      params = []
+      expr = self
+      sections = expr.split(/\s*->\s*/m)
+      if sections.length > 1 then
+          eval sections.reverse!.inject { |e, p| "(Proc.new { |#{p.split(/\s/).join(', ')}| #{e} })" }, block && block.binding
+      elsif expr.match(/\b_\b/)
+          eval "Proc.new { |_| #{expr} }", block && block.binding
+      else
+          leftSection = expr.match(/^\s*(?:[+*\/%&|\^\.=<>\[]|!=)/m)
+          rightSection = expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m)
+          if leftSection || rightSection then
+              if (leftSection) then
+                  params.push('$left')
+                  expr = '$left' + expr
+              end
+              if (rightSection) then
+                  params.push('$right')
+                  expr = expr + '$right'
+              end
+          else
+              self.gsub(
+                  /(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|self|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/, ''
+              ).scan(
+                /([a-z_$][a-z_$\d]*)/i
+              ) do |v|  
+                params.push(v) unless params.include?(v)
+              end
+          end
+          eval "Proc.new { |#{params.join(', ')}| #{expr} }", block && block.binding
+      end
+    end
+  end
 end