ruleby 0.5 → 0.6

data/lib/core/engine.rb

@@ -173,7 +173,7 @@ module Ruleby
     end
   end
 
-  # This is the core class of the library.  A new rule engine is create by 
+  # This is the core class of the library.  A new rule engine is created by 
   # instantiating it.  Each rule engine has one inference engine, one rule set
   # and one working memory.
   class Engine        

data/lib/core/nodes.rb

@@ -513,6 +513,12 @@ module Ruleby
         out_node.retract_left(fact)
       end
     end
+    
+    def retract_resolve(match)
+      @out_nodes.each do |o|
+        o.retract_resolve(match)
+      end
+    end
   end
   
   # This class is used to plug nodes into the right input of a two-input 
@@ -528,6 +534,12 @@ module Ruleby
       @out_nodes.each do |out_node|
         out_node.retract_right(fact)
       end
+    end  
+      
+    def retract_resolve(match)
+      @out_nodes.each do |o|
+        o.retract_resolve(match)
+      end
     end
   end
   
@@ -580,6 +592,19 @@ module Ruleby
         
     def to_s
       return "#{self.class}:#{object_id} | #{@left_memory.values} | #{@right_memory}"
+    end  
+      
+    def retract_resolve(match)
+      # in this method we retract an existing match from memory if it resolves
+      # with the match given.  It would probably be better to check if it 
+      # resolves with a list of facts.  But the system is not set up for
+      # that yet.
+      @left_memory.each do |fact_id,contexts|
+        contexts.delete_if do |left_context|          
+          resolve(left_context.match, match)
+        end        
+      end
+      propagate_retract_resolve(match)
     end
     
     private    
@@ -593,7 +618,8 @@ module Ruleby
             if ref_mr.is_match
               mr = mr.merge ref_mr
             else
-              return MatchResult.new
+              mr = MatchResult.new
+              break
             end
           end
           return mr
@@ -615,18 +641,6 @@ module Ruleby
           o.retract_resolve(match)
         end
       end
-      
-      def retract_resolve(match)
-        # in this method we retract an existing match from memory if it resolves
-        # with the match given.  It would probably be better to check if it 
-        # resolves with a list of facts.  But the system is not set up for
-        # that yet.
-        @left_memory.each do |fact_id,contexts|
-          value.delete_if do |left_context|          
-            resolve(left_context.match, match)
-          end        
-        end
-      end
   end
   
   # This node class is used when a rule is looking for a fact that does not 

data/lib/dsl/ferrari.rb

@@ -4,7 +4,7 @@
 # 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.
+# Copyright (c) 2009 Joe Kutner and Matt Smith. All rights reserved.
 #
 # * Authors: Joe Kutner
 #
@@ -20,37 +20,103 @@ module Ruleby
     
       def rule(name, *args, &block) 
         options = args[0].kind_of?(Hash) ? args.shift : {}        
-        
-        r = RuleBuilder.new name
+
+        parse_containers(args, RulesContainer.new).build(name,options,@engine,&block)
+      end     
+
+      private
+      def parse_containers(args, container=AndContainer.new)
+        or_builders = []
+        and_container = AndContainer.new
         args.each do |arg|
           if arg.kind_of? Array
-            r.when(*arg)
+            and_container << PatternContainer.new(arg)
+          elsif arg.kind_of? AndBuilder
+            and_container << parse_containers(arg.conditions)
+          elsif arg.kind_of? OrBuilder
+            or_builders << arg
           else
-            raise 'Invalid condition.  All or none must be Arrays.'
+            raise 'Invalid condition. Must be an OR, AND or an Array.'
           end
         end
-        
-        r.then(&block)
-        r.priority = options[:priority] if options[:priority]
-        
-        @engine.assert_rule(r.build_rule)
+                
+        if or_builders.empty?
+          container << and_container
+        else                                   
+          while !or_builders.empty?
+            or_builder = or_builders.pop          
+            parse_containers(or_builder.conditions, OrContainer.new).each do |or_container|
+              or_container.each do |or_container_child|
+                rule = AndContainer.new
+                rule.push or_container_child
+
+                or_builders.each do |sub_or_builder|
+                  parse_containers(sub_or_builder.conditions).each do |sub_or_container|
+                    rule.push *sub_or_container
+                  end
+                end
+
+                rule.push and_container
+                container << rule
+              end
+            end     
+          end
+        end  
+        return container
+      end
+    end
+
+    class RulesContainer < Array
+      def build(name,options,engine,&block)
+        self.each do |x|
+          r = RuleBuilder.new name
+          x.build r
+          r.then(&block)
+          r.priority = options[:priority] if options[:priority]
+          engine.assert_rule(r.build_rule)
+        end
+      end
+    end
+
+    class AndContainer < Array      
+      def build(builder)
+        self.each do |x|
+          x.build builder
+        end
+      end
+    end
+
+    class OrContainer < Array      
+      def build(builder)
+        # OrContainers are never built, they just contain containers that
+        # will be transformed into AndContainers.
+        raise 'Invalid Syntax'
       end
-      
     end
     
+    class PatternContainer
+      def initialize(condition)
+        @condition = condition
+      end
+      
+      def build(builder)
+        builder.when(*@condition)
+      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 = AtomBuilder === args[0] ? nil : args.shift
         is_not = false
@@ -65,19 +131,19 @@ module Ruleby
           end
           clazz = args.empty? ? nil : args.shift 
         end
-        
+
         if clazz == nil
           clazz = Object
           mode = :inherits
         end
-        
+
         deftemplate = Core::DefTemplate.new clazz, mode        
         atoms = []
         @when_counter += 1
         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|
@@ -85,20 +151,20 @@ module Ruleby
               ab.deftemplate = deftemplate
               @tags[tag] = @when_counter
               @methods[tag] = ab.name
-              atoms.push ab.build_atom(@tags, @methods, @when_counter)   
+              atoms.push *ab.build_atoms(@tags, @methods, @when_counter)
             end
           elsif arg.kind_of? AtomBuilder
             arg.tag = GeneratedTag.new
             arg.deftemplate = deftemplate
             @methods[arg.tag] = arg.name
-            atoms.push arg.build_atom(@tags, @methods, @when_counter)
+            atoms.push *arg.build_atoms(@tags, @methods, @when_counter)
           elsif arg == false
             raise 'The != operator is not allowed.'
           else
             raise "Invalid condition: #{arg}"
           end
         end  
-        
+
         if is_not 
           p = mode==:inherits ? Core::NotInheritsPattern.new(head, atoms) : 
                                 Core::NotPattern.new(head, atoms)
@@ -107,30 +173,28 @@ module Ruleby
                                 Core::ObjectPattern.new(head, atoms)
         end
         @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__]
@@ -183,12 +247,13 @@ module Ruleby
     class AtomBuilder
       attr_accessor :tag, :name, :bindings, :deftemplate, :block
       
-      def initialize(name)   
-        @name = name
+      def initialize(method_id)
+        @name = method_id
         @deftemplate = nil
-        @tag = nil
+        @tag = GeneratedTag.new
         @bindings = []
         @block = lambda {|x| true}
+        @child_atom_builders = []
       end
       
       def method_missing(method_id, *args, &block)
@@ -227,21 +292,27 @@ module Ruleby
         create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
       end 
       
-      def build_atom(tags,methods,when_id)               
+      def build_atoms(tags,methods,when_id)
+        atoms = @child_atom_builders.map { |atom_builder|
+          tags[atom_builder.tag] = when_id
+          methods[atom_builder.tag] = atom_builder.name
+          atom_builder.build_atoms(tags,methods,when_id)
+        }.flatten || []
+
         if @bindings.empty?
           if @atom_type == :equals 
-            return Core::EqualsAtom.new(@tag, @name, @deftemplate, @value) 
+            return atoms << Core::EqualsAtom.new(@tag, @name, @deftemplate, @value)
           else
-            return Core::PropertyAtom.new(@tag, @name, @deftemplate, &@block) 
+            return atoms << 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,@deftemplate,&@block)
+          atoms << Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@deftemplate,&@block)
         else
           bind_tags = @bindings.collect{ |bb| bb.tag }
-          Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,&@block)
+          atoms << Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,&@block)
         end
       end
       
@@ -265,6 +336,10 @@ module Ruleby
         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
         end
@@ -276,5 +351,19 @@ module Ruleby
         create_block value, lambda {|x,y| x != y}, lambda {|x| x != value}; self
       end
     end
+
+    class OrBuilder 
+      attr_reader :conditions
+      def initialize(conditions)
+        @conditions = conditions
+      end
+    end
+
+    class AndBuilder
+      attr_reader :conditions
+      def initialize(conditions)
+        @conditions = conditions
+      end
+    end
   end
 end

data/lib/rulebook.rb

@@ -17,13 +17,12 @@ require 'dsl/steel'
 module Ruleby
   class Rulebook
     include Ruleby
-    def initialize(engine, session={})
+    def initialize(engine, &block)
       @engine = engine
-      @session = session
+      yield self if block_given?
     end
   
     attr_reader :engine
-    attr_reader :session
     
     def assert(fact)
       @engine.assert fact
@@ -45,7 +44,7 @@ module Ruleby
         r.rule name, &block
       else
         i = args[0].kind_of?(Hash) ? 1 : 0
-        if args[i].kind_of? Array
+        if [Array, Ruleby::Ferrari::OrBuilder, Ruleby::Ferrari::AndBuilder].include? args[i].class
           # use ferrari DSL
           r = Ferrari::RulebookHelper.new @engine
           r.rule name, *args, &block
@@ -72,7 +71,7 @@ module Ruleby
     end
     
     def binding(variable_name)
-      b
+      b variable_name
     end
     
     def c(&block)
@@ -83,6 +82,14 @@ module Ruleby
       return lambda(&block)
     end
     
+    def OR(*args)
+      Ruleby::Ferrari::OrBuilder.new args
+    end
+    
+    def AND(*args)
+      Ruleby::Ferrari::AndBuilder.new args
+    end
+    
     def __eval__(x)
       eval(x)
     end

data/tests/test.rb

@@ -9,10 +9,11 @@
 # * Authors: John Mettraux
 #
 require 'common'
-require 'test_duck_type'
-require 'test_self_reference'
-require 'test_re'
-require 'gets.rb'
-require 'test_assert_facts'
+require 'duck_type'
+require 'self_reference'
+require 'regex'
+require 'gets'
+require 'assert_facts'
 require 'not_patterns'
-
+require 'or_patterns'
+require 'join_nodes'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruleby
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Joe Kutner
@@ -10,12 +10,17 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-16 00:00:00 -05:00
+date: 2009-11-23 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
-description: Ruleby is a rule engine written in the Ruby language. It is a system for executing a set  of IF-THEN statements known as production rules. These rules are matched to objects using  the forward chaining Rete algorithm. Ruleby provides an internal Domain Specific Language  (DSL) for building the productions that make up a Ruleby program.  Release Notes for Version 0.5 * reset the TerminalNode.counter when initializing the RootNode.  Thanks to Shashank for the patch. * added InitialFact so that NotPatterns can be put at the front of a rule [#1 status:resolved] * Improved rule assertion so that rules can be added after facts have been asserted [#9 state:resolved] * Added retrieve method to engine, and a unit-test for it
-email: matt@ruleby.org
+description: |
+  Ruleby is a rule engine written in the Ruby language. It is a system for executing a set 
+  of IF-THEN statements known as production rules. These rules are matched to objects using 
+  the forward chaining Rete algorithm. Ruleby provides an internal Domain Specific Language 
+  (DSL) for building the productions that make up a Ruleby program.
+
+email: jpkutner@gmail.com
 executables: []
 
 extensions: []
@@ -23,24 +28,20 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/core
 - lib/core/atoms.rb
 - lib/core/engine.rb
 - lib/core/nodes.rb
 - lib/core/patterns.rb
 - lib/core/utils.rb
-- lib/dsl
 - lib/dsl/ferrari.rb
 - lib/dsl/letigre.rb
 - lib/dsl/steel.rb
-- lib/dsl/treetop
-- lib/dsl/treetop/treetop_helper.rb
-- lib/dsl/treetop/tt_dsl.treetop
-- lib/dsl/yaml_dsl.rb
 - lib/rulebook.rb
 - lib/ruleby.rb
 has_rdoc: true
 homepage: http://ruleby.org
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -61,9 +62,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ruleby
-rubygems_version: 1.0.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Rete based Ruby Rule Engine
 test_files: 
 - tests/test.rb

data/lib/dsl/treetop/treetop_helper.rb

@@ -1,23 +0,0 @@
-
-module Ruleby
-    class TreetopHelper
-      
-      def self.rule(name, *args, &block) 
-        options = args[0].kind_of?(Hash) ? args.shift : {}        
-  
-        r = Ferrari::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]
-  
-        return r.build_rule
-      end
-    end
-end

data/lib/dsl/treetop/tt_dsl.treetop

@@ -1,105 +0,0 @@
-grammar Ruleby
-  rule root
-	  defrule* {
-			def get_rules			
-				rs = []
-				elements.each do |e|
-				  rs << e.get_rule()
-				end
-				return rs
-			end
-		}
-	end
-	
-  rule defrule
-		'rule' space name space foreach space action {
-			def get_rule()				
-			  action_text = action.text_value.strip
-			  action_text.gsub!('do', '')
-			  action_text.gsub!('end', '')
-				return foreach.get_rule(name.text_value.strip, action_text.strip)
-			end
-		}
-	end
-	
-	rule name
-		[a-zA-Z] [a-zA-Z0-9]* 
-	end
-	
-  rule foreach
-		'foreach' space head space symbol {
-		def get_rule(name, action_text)
-			class_name = head.text_value.strip
-			clazz = eval(class_name)
-	  	tag = symbol.text_value.strip	
-			tag = tag[1, tag.size - 1]
-			return Ruleby::TreetopHelper.rule(name, [clazz, tag.to_sym], &action_text)
-		end
-	}
-  end	
-
-	
-  rule action
-		'do' space (!'end' .)* 'end' space?
-	end
-	
-	
-	
-	rule head
-	  [A-Z] [a-zA-Z]*  
-	end
-	rule symbol
-	 ':' [a-zA-Z]+
-	end
-	rule where
-	  'where'
-	end
-	rule method
-	  symbol '.' [a-z] [a-zA-Z0-9]* 
-	end
-	rule string
-		'\'' [a-zA-Z0-9]* '\''
-	end
-	rule value
-	  method / '-'* [0-9]+ / symbol / string
-	end
-	rule expression
-	  value space (equal space value) / (not_equal space value) / (symbol)
-	end
-	
-	rule clause
-		expression more:(and_sign clause)* {
-		def populate
-			more.elements.each do |e|
-				e.clause.populate
-			end
-		end
-	}
-	end	
-	rule and_sign
-	  'AND' 
-	end
-	rule not_equal
-	  '!=' 
-	end
-	rule equal
-	  '=='  
-	end
-	
-  rule space
-	  white+
-	end
-
-
-	rule white
-	  blank / eol
-	end
-
-	rule blank
-	  [ \t]
-	end
-
-	rule eol
-	  ("\r" "\n"?) / "\n"
-	end
-end

data/lib/dsl/yaml_dsl.rb

@@ -1,23 +0,0 @@
-
-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