rools 0.1.6 → 0.2

data/CHANGELOG

@@ -1,5 +1,10 @@
 = Rools CHANGELOG
 
+== Rools - 0.2   released 2007/05/22
+	* specifications have been created using RSpec
+	* fix bug #10985 regarding the support of rule extension
+	* fixed assertion of a fact within a rule
+	
 == Rools - 0.1.6 released 2007/05/20
 	* todo #1319 use Rails conventions for rules parameters.  
 		WARNING: no more free for all.  

data/RAKEFILE

@@ -16,11 +16,15 @@ require 'rote/filters/tidy'
 require 'rote/format/html'
 require 'rote/extratasks'
 
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
 include Rote
 
 load 'lib/rools/version.rb'
 
-PACKAGE_VERSION = Rools::ROOLS_VERSION
+PACKAGE_VERSION   = Rools::ROOLS_VERSION
+CURRENT_COVERAGE  = Rools::ROOLS_COVERAGE
 
 CLEAN.include("pkg", "html", "rdoc", "engine.log")
 
@@ -38,7 +42,7 @@ ENV['RUBYFORGE_USER']    = "cappelaere@rubyforge.org"
 ENV['RUBYFORGE_PROJECT'] = "/var/www/gforge-projects/#{PROJECT}"
 
 desc 'Release Files'
-task :default => [:rdoc, :doc, :gem]
+task :default => [:rcov, :rdoc, :doc, :gem, :package]
 
 # Generate the RDoc documentation
 rd = Rake::RDocTask.new do |rdoc|
@@ -118,6 +122,8 @@ Rake::PackageTask.new("rools", Rools::ROOLS_VERSION) do |pkg|
         "examples/**/*",
         "lib/**/*",
         "test/**/*",
+        "specs/**/*",
+        "html/**/*"
     ].to_a
     pkg.package_files.delete("rc.txt")
     pkg.package_files.delete("MISC.txt")
@@ -170,4 +176,31 @@ RoolsTestTask.new(:test) do |t|
     t.libs << "test"
     t.test_files = FileList['test/rake_test.rb']
     t.verbose = true
-end
+end
+
+# Check Rools specifications using rspec
+Spec::Rake::SpecTask.new('specs') do |t|
+  t.spec_opts = ['--format', 'specdoc']
+  t.spec_files = FileList['specs/**/*.rb']
+end
+
+Spec::Rake::SpecTask.new('spec_coverage') do |t|
+  t.spec_opts = ['--format', 'specdoc']
+  t.spec_files = FileList['specs/**/*.rb']
+  t.rcov = true
+  t.rcov_dir = './html/output/coverage'
+  t.rcov_opts = ['--exclude', 'specs']
+end
+
+desc "Run all specs and store html output in html/output/report.html"
+Spec::Rake::SpecTask.new('spec_html') do |t|
+  t.spec_files = FileList['specs/**/*_spec.rb']
+  t.spec_opts = ['--format html:html/output/rspec_report.html','--backtrace']
+end
+
+RCov::VerifyTask.new(:verify_rcov => :spec_coverage) do |t|
+  t.threshold = CURRENT_COVERAGE # Make sure you have rcov 0.7 or higher!
+  t.index_html = './html/output/coverage/index.html'
+end
+
+task :rcov => [:verify_rcov, :spec_html]

data/lib/rools/default_parameter_proc.rb

@@ -52,15 +52,15 @@ module Rools
         if facts.has_key?( sym.to_s )
           #puts "return fact #{facts[sym.to_s].value}" 
           return facts[sym.to_s].value
-        else
+        #else
           #puts "#{sym} not 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
+      #return @working_object if @working_object && args.size == 0
+      #return nil
     end
     
     # Stops the current assertion. Does not indicate failure.

data/lib/rools/errors.rb

@@ -24,4 +24,8 @@ module Rools
   class RuleConsequenceError < RuleError
   end
   
+  # See: Rools::RuleError (RuleLoadingError is only a default derivation)
+  class RuleLoadingError < StandardError
+  end
+  
 end

data/lib/rools/facts.rb

@@ -22,5 +22,9 @@ module Rools
         @fact_value
       end
     end
+    
+    def to_s
+      "facts: #{name} #{fact_value.to_s}"
+    end
   end
 end

data/lib/rools/rule.rb

@@ -5,6 +5,7 @@ require 'rools/base'
 module Rools
   class Rule < Base
     attr_reader :name, :priority, :rule_set
+    attr_reader :parameters, :conditions, :consequences
    
     
     # A Rule requires a Rools::RuleSet, a name, and an associated block
@@ -17,7 +18,11 @@ module Rools
       @consequences = []
       @parameters   = []
       
-      instance_eval(&b) if b
+      begin
+        instance_eval(&b) if b
+      rescue Exception => e
+        raise RuleCheckError.new( self, e)
+      end
     end
     
     # Adds a condition to the Rule.
@@ -102,7 +107,7 @@ module Rools
     
     # Calls Rools::RuleSet#assert in the bound working-set
     def assert(obj)
-      @rule_set.assert(obj)
+      @rule_set.rule_assert(obj)
     end
     
     # Execute each consequence.

data/lib/rools/rule_set.rb

@@ -8,11 +8,11 @@ require 'rexml/document'
 
 module Rools
   class RuleSet < Base
-    attr_reader :num_executed, :num_evaluated, :facts
+    attr_reader :num_executed, :num_evaluated, :facts, :status
     
     PASS = :pass
     FAIL = :fail
-    
+    UNDETERMINED = :undetermined
   
     # You can pass a set of Rools::Rules with a block parameter,
     # or you can pass a file-path to evaluate.
@@ -24,7 +24,7 @@ module Rools
       
       if block_given?
         instance_eval(&b)
-      else
+      elsif file
         # loading a file, check extension
         name,ext = file.split(".")
         logger.debug("loading ext: #{name}.#{ext}") if logger
@@ -42,7 +42,7 @@ module Rools
             load_rb(file)
             
           else
-            raise "invalid file extension: #{ext}"
+            raise RuleLoadingError, "invalid file extension: #{ext}"
         end
        end
     end		
@@ -91,11 +91,10 @@ module Rools
              
              @rules[rule_name] = rule
           }
-          logger.debug( "laoded #{rules.size} rules") if logger
+          logger.debug( "loaded #{rules.size} rules") if logger
         }
       rescue Exception => e
-        puts "Load XML Exception: #{e.to_s}"
-        puts  e.backtrace.join("\n")
+        raise RuleLoadingError, "loading xml file"
       end
       
     end
@@ -107,10 +106,20 @@ module Rools
       instance_eval(File::open(file).read)
     end
     
+    #
+    # returns an array of facts
+    # 
     def get_facts
       @facts
     end
- 
+    
+    #
+    # returns all the rules defined for that set
+    # 
+    def get_rules
+      @rules
+    end
+    
     # rule creates a Rools::Rule. Make sure to use a descriptive name or symbol.
     # For the purposes of extending Rules, all names are converted to
     # strings and downcased.
@@ -196,9 +205,10 @@ module Rools
     #     condition { language.age > 15 }
     #     consequence { "In the year 2008 Ruby conquered the known universe" }
     #   end
-    def with(name, &b)
+    def with(name, prio=0, &b)
       name.to_s.downcase!
-       (@dependencies[@extend_rule_name] ||= []) << Rule.new(self, name, b)
+       (@dependencies[@extend_rule_name] ||= []) << Rule.new(self, name, prio, b)
+       #@rules[name] = Rule.new(self, name, prio, b)
     end
     
     # Stops the current assertion. Does not indicate failure.
@@ -212,83 +222,17 @@ 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_1(obj)
-      @status = PASS
-      @assert = true
-      @num_executed = 0;
-      @num_evaluated = 0;
-      
-      # 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,
-        # until there are no more matching rules available
-        begin # loop
-          
-          # the loop condition is reset to break by default after every iteration
-          matches = false
-          #logger.debug("available rules: #{available_rules.size.to_s}") if logger
-          available_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
-                available_rules.delete(rule)
-                
-                # find all parameter-matching dependencies of this rule and
-                # add them to the working-set.
-                if @dependencies.has_key?(rule.name)
-                  available_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
-              # log da error or sumpin
-              available_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 # def assert
+    #
+    # an assert has been made within a rule
+    # 
+    def rule_assert( obj )
+      # add object as a new fact
+      f = fact(obj)
+      # get_relevant_rules
+      logger.debug( "Check if we need to add more rules") if logger
+      add_relevant_rules_for_fact(f)
+      sort_relevant_rules
+    end
     
     # Turn passed object into facts and evaluate all relevant rules
     # Previous facts of same type are removed
@@ -299,28 +243,42 @@ module Rools
       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) 
+    #
+    # for a particular fact, we need to retrieve the relevant rules
+    # and add them to the relevant list
+    # 
+    def add_relevant_rules_for_fact fact
+      @rules.values.select { |rule| 
+        if !@relevant_rules.include?( rule)
+            if rule.parameters_match?(fact.value) 
               @relevant_rules << rule 
               logger.debug "#{rule} is relevant" if logger
             else
               logger.debug "#{rule} is not relevant" if logger          
             end 
-          end
-        } 
-      }
-      
+        end
+      } 
+    end
+    
+    #
+    # relevant rules need to be sorted in priority order
+    # 
+    def sort_relevant_rules
       # sort array in rule priority order
       @relevant_rules = @relevant_rules.sort do  |r1, r2| 
         r2.priority <=> r1.priority 
       end
     end
     
+    # get all relevant rules for all specified facts
+    def get_relevant_rules
+      @relevant_rules = Array.new
+      @facts.each { |k,f| 
+        add_relevant_rules_for_fact f
+      }
+      sort_relevant_rules
+    end
+    
     # evaluate all relevant rules for specified facts
     def evaluate
       @status = PASS
@@ -357,11 +315,12 @@ module Rools
                 
                 # 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
+                if @dependencies.has_key?(rule.name)
+                  logger.debug( "found dependant rules to #{rule}") if logger
+                  @relevant_rules += @dependencies[rule.name].select do |dependency|
+                    dependency.parameters_match?(obj)
+                  end
+                end
                 
                 # execute this rule
                 logger.debug("executing rule #{rule}") if logger
@@ -373,7 +332,8 @@ module Rools
               end # if rule.conditions_match?(obj)
               
             rescue RuleCheckError => e
-              logger.debug( "RuleCheckError")
+              #puts "evaluate RuleCheckError: #{e.to_s}"
+              logger.error( "RuleCheckError") if logger
               @relevant_rules.delete(e.rule)
               @status = fail
             end # begin/rescue

data/lib/rools/version.rb

@@ -1,3 +1,4 @@
 module Rools
-    ROOLS_VERSION = '0.1.6'
+    ROOLS_VERSION = '0.2'
+    ROOLS_COVERAGE = 95.1
 end

metadata

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