rools 0.1.5 → 0.1.6

data/CHANGELOG

@@ -1,5 +1,18 @@
 = Rools CHANGELOG
 
+== Rools - 0.1.6 released 2007/05/20
+	* todo #1319 use Rails conventions for rules parameters.  
+		WARNING: no more free for all.  
+		The variable used in the rule has to match the define parameter (a Class type)
+		therefore the variable has to be a lowercase singulr version of the parameter.  This is
+		required now to support multiple facts
+	* todo #1318 expand assert to accept more than one object.  You can also use a fact notation
+		to add facts and call evaluate
+	* todo #1283 rule priority completed
+	* todo #1286 added facts that can be asserted
+	* todo #1288 decision tables have been completed
+	
+	
 == Rools - 0.1.5  released 2007/04/27
 	* todo #1282 Added unit tests for baseline
 	* todo #1283 Added rule priority (not completed)

data/RAKEFILE

@@ -131,7 +131,7 @@ end
 desc "Publish RDOC to RubyForge"
 task :rubyforge => [:rdoc, :gem] do
   Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'html').upload
-  Rake::SshFilePublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'pkg', "#{PROJECT}-#{PACKAGE_VERSION}.gem").upload  
+  #Rake::SshFilePublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'pkg', "#{PROJECT}-#{PACKAGE_VERSION}.gem").upload  
 end
 
 # Builds the website and uploads it to Rubyforge.org

data/lib/rools/csv_table.rb

@@ -30,7 +30,7 @@ module Rools
       parameter = arrs[1][1]
       #puts "parameter:#{parameter}"
       
-      # get rule elements
+      # get rule elements Conditions/Consequences
       rule_elements = arrs[2]
       
       # get code
@@ -47,34 +47,43 @@ module Rools
       @rules  = ""
       arrs[5..arrs.size].each { |arr|
         rule_name = "rule_#{index}"
-        #puts "arr:#{arr}"
+        #puts "arr:#{arr} index: #{index}"
         
-        @rules << "rule '#{rule_name}' do \n"
+        #if rule_elements[index] != nil
+          @rules << "rule '#{rule_name}' do \n"
           @rules << "  parameter #{parameter}\n"
           column = 0
+          
           rule_elements.each do |element|
             
-            field  = headers[column].downcase
+            field  = headers[column].downcase if headers[column]
             str    = arr[column]
             
-            if str != nil
+            if str != nil && element != nil
               #puts ("eval: #{field} = '#{str}'")
               #eval( "#{field} = '#{str}'" )
   
               @rules << "\t" + element.downcase + "{ "
               pattern = "\#\{#{field}\}"
               
-              statement = rule_code[column].gsub(pattern,quote(str))
-    
-              #puts "statement:#{statement}"
+              #puts rule_code[column]
+              #puts "pattern: #{pattern} str:#{str}"
+              if rule_code[column] == pattern
+                statement = str # straight replace
+              else
+                statement = rule_code[column].gsub(pattern,quote(str))
+              end
               
-              @rules << statement
+              #puts "statement:#{statement}"
               
+              @rules << statement     
               @rules << "}\n"
             end
+            
             column += 1
           end
-        @rules << "end\n"
+          @rules << "end\n"
+        #end
         index += 1
       }
     end

data/lib/rools/default_parameter_proc.rb

@@ -45,18 +45,19 @@ module Rools
     # Parameterless method calls by the attached block are assumed to
     # be references to the working object
     def method_missing(sym, *args)
-      # puts "method missing: #{sym}"
+      #puts "method missing: #{sym}"
       # check if it is a fact first
       begin
         facts = @rule.rule_set.get_facts
         if facts.has_key?( sym.to_s )
-          #puts "return fact #{rsfacts[sym.to_s].fact_value}"
-          return facts[sym.to_s].fact_value
+          #puts "return fact #{facts[sym.to_s].value}" 
+          return facts[sym.to_s].value
         else
-          #puts "#{sym} not in facts"
+          #puts "#{sym} not in facts" 
         end
       rescue Exception => e
-        logger.error "miss exception #{e} #{e.backtrace.join("\n")}" if logger
+        #logger.error "miss exception #{e} #{e.backtrace.join("\n")}" if logger
+        #puts "miss exception #{e} #{e.backtrace.join("\n")}"
       end
       return @working_object if @working_object && args.size == 0
       return nil

data/lib/rools/facts.rb

@@ -2,6 +2,9 @@ require 'rools/errors'
 require 'rools/default_parameter_proc'
 require 'rools/base'
 
+#
+# Facts are collections or recordsets created by the user
+# 
 module Rools
   class Facts < Base
     attr_reader :name, :fact_value
@@ -9,7 +12,15 @@ module Rools
     def initialize(rule_set, name, b)
       @name = name
       @fact_value = instance_eval( &b )
-      logger.debug "New Facts: #{@fact_value}" if logger
+      #logger.debug "New Facts: #{@fact_value}" if logger
+    end
+    
+    def value
+      if @fact_value.size == 1
+        @fact_value[0]
+      else
+        @fact_value
+      end
     end
   end
 end

data/lib/rools/rule.rb

@@ -10,9 +10,9 @@ module Rools
     # A Rule requires a Rools::RuleSet, a name, and an associated block
     # which will be executed at initialization
     def initialize(rule_set, name, priority, b)
-      @rule_set = rule_set
-      @name     = name
-      @priority = priority
+      @rule_set     = rule_set
+      @name         = name
+      @priority     = priority
       @conditions   = []
       @consequences = []
       @parameters   = []
@@ -55,6 +55,7 @@ module Rools
     # To verify that the asserted object is an Employee, that inherits from
     # Person, and responds to :department
     def parameters(*matches)
+      logger.debug( "Adding parameters: #{matches}") if logger
       @parameters += matches
     end
     
@@ -65,16 +66,25 @@ module Rools
     # Checks to see if this Rule's parameters match the asserted object
     def parameters_match?(obj)
       @parameters.each do |p|
-        logger.debug( "match p:#{p} obj:#{obj} sym:#{Symbol}") if logger
+        logger.debug( "#{self} match p:#{p} obj:#{obj} sym:#{Symbol}") if logger
         if p.is_a?(Symbol)
-          return false unless obj.respond_to?(p)
+          #return false unless obj.respond_to?(p)
+          return true if obj.respond_to?(p)
         else
-          logger.debug( "is_a p:#{p} obj:#{obj} #{obj.is_a?(p)}") if logger
-          return false unless obj.is_a?(p)
+          logger.debug( "#{self} is_a p:#{p} obj:#{obj} #{obj.is_a?(p)}") if logger
+          #return false unless obj.is_a?(p)
+          return true if obj.is_a?(p)
         end
       end
       
-      return true
+      # if parameters are not specified, let's assume that the rule is always relevant
+      if @parameters.size == 0
+        logger.debug "no parameters defined for rule: #{self}" if logger
+        return true
+      end
+      
+      logger.debug( "no parameter match") if logger
+      return false
     end
     
     # Checks to see if this Rule's conditions match the asserted object
@@ -105,6 +115,7 @@ module Rools
         end
       rescue StandardError => e
         # discontinue the Rools::RuleSet#assert if any consequence fails
+        logger.error( "rule RuleConsequenceError #{e.to_s} #{e.backtrace.join("\n")}") if logger
         raise RuleConsequenceError.new(rule, e)
       end
     end

data/lib/rools/rule_set.rb

@@ -27,7 +27,7 @@ module Rools
       else
         # loading a file, check extension
         name,ext = file.split(".")
-        logger.debug("loading ext: #{ext}") if logger
+        logger.debug("loading ext: #{name}.#{ext}") if logger
         case ext
           when 'csv'
             load_csv( file )
@@ -60,34 +60,44 @@ module Rools
     # XML File format loading
     #
     def load_xml( fileName )
-      file = File.new( fileName )
-      doc = REXML::Document.new file
-      doc.elements.each( "rule-set") { |rs| 
-        facts = rs.elements.each( "facts") { |f| 
-          facts( f.attributes["name"] ) do f.text.strip end
-        }
-        
-        rules = rs.elements.each( "rule") { |rule_node|
-           rule_name  = rule_node.attributes["name"]
-           priority   = rule_node.attributes["priority"]
-           
-           rule       = Rule.new(self, rule_name, priority, nil)
-           
-           parameters = rule_node.elements.each("parameter") { |param|
-              rule.parameter do eval(param.text.strip) end
-           } 
-           
-           conditions = rule_node.elements.each("condition") { |cond|
-              rule.condition do eval(cond.text.strip) end
-           } 
- 
-           consequences = rule_node.elements.each("consequence") { |cons|
-              rule.consequence do eval(cons.text.strip) end
-           } 
-           
-           @rules[rule_name] = rule
+      begin
+        file = File.new( fileName )
+        doc = REXML::Document.new file
+        doc.elements.each( "rule-set") { |rs| 
+          facts = rs.elements.each( "facts") { |f| 
+            facts( f.attributes["name"] ) do f.text.strip end
+          }
+          
+          rules = rs.elements.each( "rule") { |rule_node|
+             rule_name  = rule_node.attributes["name"]
+             priority   = rule_node.attributes["priority"]
+             
+             rule       = Rule.new(self, rule_name, priority, nil)
+             
+             parameters = rule_node.elements.each("parameter") { |param|
+                #logger.debug "xml parameter: #{param.text.strip}"
+                rule.parameters(eval(param.text.strip))
+             } 
+             
+             conditions = rule_node.elements.each("condition") { |cond|
+                #logger.debug "xml condition #{cond}"
+                rule.condition do eval(cond.text.strip) end
+             } 
+   
+             consequences = rule_node.elements.each("consequence") { |cons|
+               #logger.debug "xml consequence #{cons}"
+               rule.consequence do eval(cons.text.strip) end
+             } 
+             
+             @rules[rule_name] = rule
+          }
+          logger.debug( "laoded #{rules.size} rules") if logger
         }
-      }
+      rescue Exception => e
+        puts "Load XML Exception: #{e.to_s}"
+        puts  e.backtrace.join("\n")
+      end
+      
     end
     
     #
@@ -138,8 +148,36 @@ module Rools
     def facts(name, &b)
       name.to_s.downcase!
       @facts[name] = Facts.new(self, name, b)
+     logger.debug( "created facts: #{name}") if logger
+    end
+    
+    # A single fact can be an single object of a particular class type
+    # or a collection of objects of a particular type
+    def fact( obj )
+      begin
+        # check if facts already exist for that class
+        # if so, we need to add it to the existing list
+        cls = obj.class.to_s.downcase
+        
+        if @facts.key? cls
+          logger.debug( "adding to facts: #{cls}") if logger
+          @facts[cls].fact_value << obj
+        else
+          logger.debug( "creating facts: #{cls}") if logger
+          arr = Array.new
+          arr << obj
+          proc = Proc.new { arr }
+          @facts[cls] = Facts.new(self, cls, proc ) 
+        end
+      rescue Exception=> e
+        logger.error e if logger
+      end
     end
     
+    # Delete all existing facts
+    def delete_facts
+        @facts = {}
+    end
     
     # Use in conjunction with Rools::RuleSet#with to create a Rools::Rule dependent on
     # another. Dependencies are created through names (converted to
@@ -174,9 +212,11 @@ module Rools
       @assert = false
     end
     
+ 
+    
     # Used to create a working-set of rules for an object, and evaluate it
     # against them. Returns a status, simply PASS or FAIL
-    def assert(obj)
+    def assert_1(obj)
       @status = PASS
       @assert = true
       @num_executed = 0;
@@ -185,6 +225,10 @@ module Rools
       # create a working-set of all parameter-matching, non-dependent rules
       available_rules = @rules.values.select { |rule| rule.parameters_match?(obj) }
       
+      available_rules = available_rules.sort do  |r1, r2| 
+        r2.priority <=> r1.priority 
+      end
+      
       begin
         
         # loop through the available_rules, evaluating each one,
@@ -246,5 +290,109 @@ module Rools
       return @status
     end # def assert
     
+    # Turn passed object into facts and evaluate all relevant rules
+    # Previous facts of same type are removed
+    def assert( *objs )
+      objs.each { |obj| 
+        fact(obj)
+      }
+      return evaluate()
+    end
+    
+    # get all relevant rules for all specified facts
+    def get_relevant_rules
+      @relevant_rules = Array.new
+      @facts.each { |k,f| 
+        @rules.values.select { |rule| 
+          if !@relevant_rules.include?( rule)
+            if rule.parameters_match?(f.value) 
+              @relevant_rules << rule 
+              logger.debug "#{rule} is relevant" if logger
+            else
+              logger.debug "#{rule} is not relevant" if logger          
+            end 
+          end
+        } 
+      }
+      
+      # sort array in rule priority order
+      @relevant_rules = @relevant_rules.sort do  |r1, r2| 
+        r2.priority <=> r1.priority 
+      end
+    end
+    
+    # evaluate all relevant rules for specified facts
+    def evaluate
+      @status = PASS
+      @assert = true
+      @num_executed = 0;
+      @num_evaluated = 0;
+      
+      get_relevant_rules()
+      logger.debug("no relevant rules") if logger && @relevant_rules.size==0
+      
+      begin #rescue
+        
+        # loop through the available_rules, evaluating each one,
+        # until there are no more matching rules available
+        begin # loop
+          
+          # the loop condition is reset to break by default after every iteration
+          matches = false
+          obj     = nil #deprecated
+ 
+          #logger.debug("available rules: #{available_rules.size.to_s}") if logger
+          @relevant_rules.each do |rule|
+            # RuleCheckErrors are caught and swallowed and the rule that
+            # raised the error is removed from the working-set.
+            logger.debug("evaluating: #{rule}") if logger
+            begin
+              @num_evaluated += 1
+              if rule.conditions_match?(obj)
+                logger.debug("rule #{rule} matched") if logger
+                matches = true
+                
+                # remove the rule from the working-set so it's not re-evaluated
+                @relevant_rules.delete(rule)
+                
+                # find all parameter-matching dependencies of this rule and
+                # add them to the working-set.
+                #if @dependencies.has_key?(rule.name)
+                #  @relevant_rules += @dependencies[rule.name].select do |dependency|
+                #    dependency.parameters_match?(obj)
+                #  end
+                #end
+                
+                # execute this rule
+                logger.debug("executing rule #{rule}") if logger
+                rule.call(obj)
+                @num_executed += 1
+                
+                # break the current iteration and start back from the first rule defined.
+                break
+              end # if rule.conditions_match?(obj)
+              
+            rescue RuleCheckError => e
+              logger.debug( "RuleCheckError")
+              @relevant_rules.delete(e.rule)
+              @status = fail
+            end # begin/rescue
+            
+          end # available_rules.each
+          
+        end while(matches && @assert)
+        
+      rescue RuleConsequenceError => rce
+        # RuleConsequenceErrors are allowed to break out of the current assertion,
+        # then the inner error is bubbled-up to the asserting code.
+        @status = fail
+        raise rce.inner_error
+      end
+      
+      @assert = false
+      
+      return @status
+    end
+    
   end # class RuleSet
 end # module Rools

data/lib/rools/version.rb

@@ -1,3 +1,3 @@
 module Rools
-    ROOLS_VERSION = '0.1.5'
+    ROOLS_VERSION = '0.1.6'
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rools
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2007-04-27 00:00:00 -04:00
+  version: 0.1.6
+date: 2007-05-20 00:00:00 -04:00
 summary: A Rules Engine written in Ruby
 require_paths: 
 - lib