rools 0.2 → 0.3

data/CHANGELOG

@@ -1,5 +1,12 @@
 = Rools CHANGELOG
 
+== Rools - 0.3
+	* facts can now have a defined namespace
+    * fixed csv_test
+    * added load_xml_rules_as_string and load_rb_rules_as_string
+	* 100% test coverage
+	* Applied doc patch from John Mettraux
+	
 == Rools - 0.2   released 2007/05/22
 	* specifications have been created using RSpec
 	* fix bug #10985 regarding the support of rule extension

data/RAKEFILE

@@ -144,20 +144,30 @@ end
 task :upload_website => [:doc] do
     sh """
 rsync -azv -e ssh \
+--exclude='.svn' --delete-excluded \
 html/ \
-ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+cappelaere@rubyforge.org:/var/www/gforge-projects/rools \
     """
     sh """
 rsync -azv -e ssh \
 --exclude='.svn' --delete-excluded \
 doc/res/defs \
-ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+cappelaere@rubyforge.org:/var/www/gforge-projects/rools \
     """
     sh """
 rsync -azv -e ssh \
 --exclude='.svn' --delete-excluded \
 examples \
-ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+cappelaere@rubyforge.org:/var/www/gforge-projects/rools \
+    """
+end
+
+task :upload_html do
+    sh """
+rsync -azv -e ssh \
+--exclude='.svn' \
+html \
+cappelaere@rubyforge.org:/var/www/gforge-projects/rools \
     """
 end
 

data/README

@@ -1,4 +1,4 @@
-:nodoc: YOU SHOULD NOT BE VIEWING THIS FILE DIRECTLY. PLEASE USE: gem_server
+
 = Rools -- A pure ruby rules-engine
 
 Rools is a rules engine for abstracting business logic and program-flow. It's ideally suited to processing applications where the business logic undergoes frequent modification.

data/lib/rools/default_parameter_proc.rb

@@ -25,15 +25,15 @@ module Rools
       raise ArgumentError.new('The "rule" parameter must respond to an :assert method') unless rule.respond_to?(:assert)
       @rule = rule
       @proc = b
-      @working_object = nil
+      #@working_object = nil
     end
     
     # Call the bound block and set the working object so that it
     # can be referred to by method_missing
     def call(obj)
-      @working_object = obj
+      #@working_object = obj
       status = instance_eval(&@proc)
-      @working_object = nil
+      #@working_object = nil
       return status
     end
     
@@ -45,22 +45,20 @@ 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} args:#{args.inspect}"
       # check if it is a fact first
-      begin
+      #begin
         facts = @rule.rule_set.get_facts
         if facts.has_key?( sym.to_s )
           #puts "return fact #{facts[sym.to_s].value}" 
           return facts[sym.to_s].value
-        #else
-          #puts "#{sym} not in facts" 
+        else
+          raise Exception, "symbol: #{sym} not found in facts"
         end
-      rescue Exception => e
-        #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
+      #rescue Exception => e
+      #  puts "miss exception #{e} #{e.backtrace.join("\n")}"
+      #  return nil
+      #end
     end
     
     # Stops the current assertion. Does not indicate failure.

data/lib/rools/rule.rb

@@ -60,8 +60,16 @@ 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
+      logger.debug( "Adding parameters: #{matches.inspect}") if logger
+#     @parameters += matches
+      @parameters << matches
+    end
+    
+    #
+    # returns parameters of rule
+    # 
+    def get_parameters
+      @parameters
     end
     
     # parameters is aliased to aid in readability if you decide
@@ -70,25 +78,31 @@ module Rools
     
     # Checks to see if this Rule's parameters match the asserted object
     def parameters_match?(obj)
-      @parameters.each do |p|
-        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 true if obj.respond_to?(p)
-        else
-          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
-      
       # 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
+      @parameters.each do |params|
+        match = false
+        
+        params.each do  |p|
+          logger.debug( "#{self} match p:#{p} obj:#{obj}") if logger
+        
+          if p.is_a?(Symbol) 
+            if obj.respond_to?(p)
+              match = true
+            else
+              return false
+            end
+          elsif obj.is_a?(p)
+            match = true
+          end
+        end
+        return true if match
+      end
+     
       return false
     end
     
@@ -98,7 +112,7 @@ module Rools
       begin
         @conditions.each { |c| return false unless c.call(obj) }
       rescue StandardError => e
-        logger.error( "rule StandardError #{e} #{e.backtrace.join("\n")}") if logger
+        logger.error( "conditions_match? StandardError #{e} #{e.backtrace.join("\n")}") if logger
         raise RuleCheckError.new(self, e)
       end
       
@@ -118,10 +132,10 @@ module Rools
         @consequences.each do |c|
           c.call(obj)
         end
-      rescue StandardError => e
+      rescue Exception => 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)
+        raise RuleConsequenceError.new(self, e)
       end
     end
     

data/lib/rools/rule_set.rb

@@ -61,8 +61,17 @@ module Rools
     #
     def load_xml( fileName )
       begin
-        file = File.new( fileName )
-        doc = REXML::Document.new file
+        str = IO.read(fileName)
+        load_xml_rules_as_string(str)
+      rescue Exception => e
+        raise RuleLoadingError, "loading xml file"
+      end
+    end
+    
+    # load xml rules as a string
+    def load_xml_rules_as_string( str )
+      begin
+        doc = REXML::Document.new str
         doc.elements.each( "rule-set") { |rs| 
           facts = rs.elements.each( "facts") { |f| 
             facts( f.attributes["name"] ) do f.text.strip end
@@ -100,10 +109,20 @@ module Rools
     end
     
     #
-    # Ruby File format
+    # Ruby File format loading
     #
     def load_rb( file )
-      instance_eval(File::open(file).read)
+      begin
+        str = IO.read(file)
+        load_rb_rules_as_string(str)
+      rescue Exception => e
+        raise RuleLoadingError, "loading ruby file"
+      end
+    end
+    
+    # load ruby rules as a string
+    def load_rb_rules_as_string( str )
+      instance_eval(str)    
     end
     
     #
@@ -136,25 +155,28 @@ module Rools
     # facts can be created in a similar manner to rules
     # all names are converted to strings and downcased.
     # Facts name is equivalent to a Class Name
+    #	
     # ==Example
-    # require 'rools'
-	#
-	# rules = Rools::RuleSet.new do
-	#	
-	#	facts 'Countries' do
-	#		["China", "USSR", "France", "Great Britain", "USA"]
-	#	end
-	#	
-	#	rule 'Is it on Security Council?' do
-	#	  parameter String
-	#		condition { countries.include?(string) }
-	#		consequence { puts "Yes, #{string} is in the country list"}
-	#	end
-	# end
+    #	
+    #     require 'rools'
+    #
+    #     rules = Rools::RuleSet.new do
+    #       
+    #       facts 'Countries' do
+    #       	["China", "USSR", "France", "Great Britain", "USA"]
+    #       end
+    #       
+    #       rule 'Is it on Security Council?' do
+    #         parameter String
+    #       	condition { countries.include?(string) }
+    #       	consequence { puts "Yes, #{string} is in the country list"}
+    #       end
+    #     end
     #
-	# rules.assert 'France'
+    #     rules.assert 'France'
     #
     def facts(name, &b)
+      name.gsub!(/:/, '_')
       name.to_s.downcase!
       @facts[name] = Facts.new(self, name, b)
      logger.debug( "created facts: #{name}") if logger
@@ -163,11 +185,11 @@ module Rools
     # 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
+      #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
-        
+        cls.gsub!(/:/, '_')
         if @facts.key? cls
           logger.debug( "adding to facts: #{cls}") if logger
           @facts[cls].fact_value << obj
@@ -178,9 +200,9 @@ module Rools
           proc = Proc.new { arr }
           @facts[cls] = Facts.new(self, cls, proc ) 
         end
-      rescue Exception=> e
-        logger.error e if logger
-      end
+      #rescue Exception=> e
+      #  logger.error e if logger
+      #end
     end
     
     # Delete all existing facts
@@ -289,7 +311,7 @@ module Rools
       get_relevant_rules()
       logger.debug("no relevant rules") if logger && @relevant_rules.size==0
       
-      begin #rescue
+      #begin #rescue
         
         # loop through the available_rules, evaluating each one,
         # until there are no more matching rules available
@@ -331,23 +353,22 @@ module Rools
                 break
               end # if rule.conditions_match?(obj)
               
+            rescue RuleConsequenceError
+              fail
             rescue RuleCheckError => e
-              #puts "evaluate RuleCheckError: #{e.to_s}"
-              logger.error( "RuleCheckError") if logger
-              @relevant_rules.delete(e.rule)
-              @status = fail
+              fail
             end # begin/rescue
             
           end # available_rules.each
           
         end while(matches && @assert)
         
-      rescue RuleConsequenceError => rce
+      #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
+      #  @status = FAIL
+      #  raise rce.inner_error
+      #end
       
       @assert = false
       
@@ -355,4 +376,4 @@ module Rools
     end
     
   end # class RuleSet
-end # module Rools
+end # module Rools

data/lib/rools/version.rb

@@ -1,4 +1,4 @@
 module Rools
-    ROOLS_VERSION = '0.2'
-    ROOLS_COVERAGE = 95.1
+    ROOLS_VERSION = '0.3'
+    ROOLS_COVERAGE = 100.0
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rools
 version: !ruby/object:Gem::Version 
-  version: "0.2"
-date: 2007-05-22 00:00:00 -04:00
+  version: "0.3"
+date: 2007-07-18 00:00:00 -04:00
 summary: A Rules Engine written in Ruby
 require_paths: 
 - lib