rools 0.1.4 → 0.1.5

data/CHANGELOG

@@ -1,17 +1,27 @@
-- 0.1.4
+= Rools CHANGELOG
+
+== Rools - 0.1.5  released 2007/04/27
+	* todo #1282 Added unit tests for baseline
+	* todo #1283 Added rule priority (not completed)
+	* todo #1284 Added XML rule format
+	* todo #1286 Added facts support
+	* todo #1287 Added decision table capability
+	* todo #1288 Added logging capability to trace engine
+	* todo #1292 Major Rakefile upgrade for site auto-generation (Thanks to John Metttraux)
+		
+== Rools - 0.1.4 released 2005/12/15
 	* Removed "examples" folder since my RDoc kung-fu cannot be denied and the examples were redundant
 	* Added Rools::open to rools.rb
 	* Added pscp.rb to create SshPublishers on Win32 with PuttySCP
 	* Added Rools::RuleSet#assert return codes, :pass and :fail
-	* Added stop and fail methods to RuleSet, Rules, and DefaultParameterProc
-	* Built Gem under Ruby 1.8.2 to fix yaml bug for RubyForge distribution
+	* Added stop and fail methods to RuleSet, Rules, and DefaultParameterProc
 
-- 0.1.3
+== Rools - 0.1.3
 	Finished most documentation
 	Tweaked the rakefile
 		
-- 0.1.2
+== Rools - 0.1.2
 	Added RAKEFILE, README, CHANGELOG
 	
-- 0.1.1
+== Rools - 0.1.1
 	Added RuleConsequenceError

data/RAKEFILE

@@ -1,35 +1,77 @@
 require 'rubygems'
 require 'rake'
-require 'rake/rdoctask'
+require 'rake/clean'
+require 'rake/packagetask'
 require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
 require 'rake/contrib/rubyforgepublisher'
-require 'pscp'
 
-PACKAGE_VERSION = '0.1.4'
+#require 'pscp'
+require 'rote'
+require 'rote/filters'
+require 'rote/filters/redcloth'
+require 'rote/filters/tidy'
+require 'rote/format/html'
+require 'rote/extratasks'
+
+include Rote
+
+load 'lib/rools/version.rb'
+
+PACKAGE_VERSION = Rools::ROOLS_VERSION
+
+CLEAN.include("pkg", "html", "rdoc", "engine.log")
 
 PACKAGE_FILES = FileList[
   'README',
   'CHANGELOG',
   'RAKEFILE',
+  'lib/rools.rb',
   'lib/**/*.rb'
 ].to_a
 
 PROJECT = 'rools'
 
-ENV['RUBYFORGE_USER'] = "ssmoot@rubyforge.org"
+ENV['RUBYFORGE_USER']    = "cappelaere@rubyforge.org"
 ENV['RUBYFORGE_PROJECT'] = "/var/www/gforge-projects/#{PROJECT}"
 
 desc 'Release Files'
-task :default => [:rdoc]
+task :default => [:rdoc, :doc, :gem]
 
 # Generate the RDoc documentation
 rd = Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'doc'
+  rdoc.rdoc_dir = 'html/doc'
   rdoc.title = 'Rools -- A Pure Ruby Rules Engine'
-  rdoc.options << '--line-numbers --inline-source --main README'
   rdoc.rdoc_files.include(PACKAGE_FILES)
+  rdoc.options << '-N'
+  rdoc.options << '-S'
+end
+
+# Create a task to build the static docs (html)
+ws = Rote::DocTask.new(:doc) do |site| 
+    site.output_dir = 'html'
+    site.layout_dir = 'doc/layouts'
+    site.pages.dir  = 'doc/pages'
+    site.pages.include('**/*')  
+  
+    site.ext_mapping(/thtml|textile/, 'html') do |page|
+        page.extend Format::HTML
+        page.page_filter Filters::RedCloth.new
+        page.page_filter Filters::Syntax.new
+    end
+
+    site.res.dir = 'doc/res'
+    site.res.include('**/*.png')
+    site.res.include('**/*.gif')
+    site.res.include('**/*.jpg')
+    site.res.include('**/*.css')
 end
 
+# Add rdoc deps to doc task
+task :doc => [:rdoc]
+
 gem_spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.name = PROJECT
@@ -37,10 +79,10 @@ gem_spec = Gem::Specification.new do |s|
   s.description = "Can be used for program-flow, ideally suited to processing applications"
   s.version = PACKAGE_VERSION
   
-  s.authors = 'Sam Smoot', 'Scott Bauer'
-  s.email = 'ssmoot@gmail.com; bauer.mail@gmail.com'
+  s.authors = 'Sam Smoot', 'Scott Bauer', 'Pat Cappelaere'
+  s.email = 'ssmoot@gmail.com; bauer.mail@gmail.com cappelaere@gmail.com'
   s.rubyforge_project = PROJECT
-  s.homepage = 'http://substantiality.net'
+  s.homepage = 'http://rools.rubyforge.org/'
   
   s.files = PACKAGE_FILES
   
@@ -53,13 +95,79 @@ gem_spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
 end
 
+#
+# Create a task for creating a ruby gem
+#
 Rake::GemPackageTask.new(gem_spec) do |p|
   p.gem_spec = gem_spec
   p.need_tar = true
   p.need_zip = true
 end
 
+#
+# Packaging the source
+#
+Rake::PackageTask.new("rools", Rools::ROOLS_VERSION) do |pkg|
+    pkg.need_zip = true
+    pkg.package_files = FileList[
+        "RAKEFILE",
+        "CHANGELOG",
+        "README",
+        "*.txt",
+        "doc/**/*",
+        "examples/**/*",
+        "lib/**/*",
+        "test/**/*",
+    ].to_a
+    pkg.package_files.delete("rc.txt")
+    pkg.package_files.delete("MISC.txt")
+    class << pkg
+        def package_name
+            "#{@name}-#{@version}-src"
+        end
+    end
+end
+
 desc "Publish RDOC to RubyForge"
 task :rubyforge => [:rdoc, :gem] do
-  Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'doc').upload
+  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  
+end
+
+# Builds the website and uploads it to Rubyforge.org
+task :upload_website => [:doc] do
+    sh """
+rsync -azv -e ssh \
+html/ \
+ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+    """
+    sh """
+rsync -azv -e ssh \
+--exclude='.svn' --delete-excluded \
+doc/res/defs \
+ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+    """
+    sh """
+rsync -azv -e ssh \
+--exclude='.svn' --delete-excluded \
+examples \
+ENV['RUBYFORGE_USER']:ENV['RUBYFORGE_PROJECT']
+    """
+end
+
+#
+# TEST TASKS
+#
+class RoolsTestTask < Rake::TestTask
+    def initialize (name=nil)
+        File.delete "engine.log" if File.exist? "engine.log"
+        super(name)
+    end
+end
+
+# Create a task for handling Unit Tests
+RoolsTestTask.new(:test) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/rake_test.rb']
+    t.verbose = true
 end

data/README

@@ -3,36 +3,35 @@
 
 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.
 
+== RubyForge
+	This documentation can be found at http://rools.rubyforge.org
+	The project page can be found at http://rubyforge.org/projects/rools
+	
 == Example
 
 	require 'rools'
 	
 	rules = Rools::RuleSet.new do
 		
-		rule 'Is it a String?' do
+		rule 'Hello?' do
 			parameter String
-			consequence { puts "Yes, it's a String" }
-		end
-		
-		rule 'Is it a country?' do
-			condition { Country.find_all.collect { |c| c.name }.include?(string) }
-			consequence { puts "Yes, #{string} is in the country list"}
+			consequence { puts "Hello, Rools!" }
 		end
 	end
 	
-	rules.assert 'Japan'
+	rules.assert 'Heya'
 	
-	> Yes, it's a String
-	> Yes, Japan is in the country list
+	> Hello, Rools!
+
 	
-You can also store your rules in a seperate file, and pass a path to Rools::RuleSet#new instead of a block. e.g.
+You can also store your rules in a separate file, and pass a path to Rools::RuleSet#new instead of a block. e.g.
 	
 	require 'rools'
 	
-	rules = Rools::RuleSet.new 'countries.rules'
-	rules.assert 'Japan'
-	
-== Parameter
+	rules = Rools::RuleSet.new 'test/data/hello.rules'
+	rules.assert 'heya'
+
+=== Parameter
 
 The +parameter+ method accepts Constants and/or Symbols. Every constant in the list is called with :is_a? on the asserted object, while every symbol in the list is passed to :respond_to? on the asserted object. In other words:
 
@@ -42,9 +41,9 @@ Is effectively the same as:
 
 	condition { object.is_a?(Person) && object.responds_to?(:name) && object.responds_to?(:occupation) }
 	
-The +parameter+ method is obviously preferred for it's conciseness, and because the working set of rules can be optimized to only include for evaluation (to-do), those rules whose parameters match the asserted object.
+The +parameter+ method is obviously preferred for it's conciseness, and because the working set of rules can be optimized to only include for evaluation those rules whose parameters match the asserted object.
 
-== Condition
+=== Condition
 
 The +condition+ method is used to evaluate the asserted object. You can have any number of conditions. Rools::DefaultParameterProc#method_missing is used so that you can refer to the asserted object by practically any +lower_case_underscore+ name. Generally you'll want to use names that make sense in the context of the +Rule+, and be consistent through-out the +Rule+. Here's an example:
 
@@ -62,7 +61,7 @@ Here's an example of something you might want to avoid:
 
 Both examples are syntactically correct, but the first is easier to read.
 
-== Consequence
+=== Consequence
 
 A consequence is a block of code that executes if the conditions evaluate to true. You can have one or more consequences. In the above examples we're doing something simple such as just printing something to the string in the consequences. Usually the consequence is something that will actually change the state of the asserted object in some way however.
 
@@ -74,7 +73,7 @@ A consequence is a block of code that executes if the conditions evaluate to tru
 	
 Nevermind that this is application logic you'd probably keep in your domain model. The intent isn't to show you best-practices here, only to make the point that consequences usually modify state.
 
-== Assert
+=== Assert
 
 What happens if in a +consequence+, you need to create other objects though? You can use the +assert+ method in a +consequence+. Consider the following:
 
@@ -98,7 +97,7 @@ The first rule asserted a new +Referral+ object into the RuleSet. You could also
 
 	consequence { RuleSet.new('referral.rules').assert Referral.new(message) }
 	
-== Extend
+=== Extend
 
 Problem: You have a sequence of rules that depend on each other:
 

data/lib/rools/base.rb

@@ -0,0 +1,13 @@
+module Rools
+ class Base
+    @@logger = nil
+    
+    def logger
+      return @@logger
+    end
+    
+    def self.logger= (newlogger)
+      @@logger = newlogger
+    end
+  end
+end

data/lib/rools/csv_table.rb

@@ -0,0 +1,85 @@
+#require 'rubygems'
+#require_gem 'fastercsv'
+require 'csv'
+require 'rools/base'
+
+module Rools
+  
+  class CsvTable < Base
+    attr_reader :rules
+  
+    #
+    # return quoted String or Number
+    # There is probably a more elagant way of doing this but...
+    # 
+    def quote( str )
+      return str if (str.to_i.to_s == str)
+      return str if (str.to_f.to_s == str)
+      '"' + str + '"'
+    end
+    
+    def initialize( fileName )
+      csv_data = IO.read( fileName)
+      arrs = []
+      CSV::Reader.parse(csv_data, ",", "\r") do |row|
+        #puts "row:#{row.inspect}"
+        arrs << row
+      end
+      
+      # get rule parameter 
+      parameter = arrs[1][1]
+      #puts "parameter:#{parameter}"
+      
+      # get rule elements
+      rule_elements = arrs[2]
+      
+      # get code
+      rule_code = arrs[3]      
+      
+      # get headers
+      headers = arrs[4]
+      
+      #get number of rules
+      num_rules = arrs.size-5
+      #puts "num rules: #{num_rules}"
+      
+      index   = 0
+      @rules  = ""
+      arrs[5..arrs.size].each { |arr|
+        rule_name = "rule_#{index}"
+        #puts "arr:#{arr}"
+        
+        @rules << "rule '#{rule_name}' do \n"
+          @rules << "  parameter #{parameter}\n"
+          column = 0
+          rule_elements.each do |element|
+            
+            field  = headers[column].downcase
+            str    = arr[column]
+            
+            if str != 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}"
+              
+              @rules << statement
+              
+              @rules << "}\n"
+            end
+            column += 1
+          end
+        @rules << "end\n"
+        index += 1
+      }
+    end
+  end
+  
+ 
+  
+end

data/lib/rools/default_parameter_proc.rb

@@ -1,9 +1,10 @@
+require 'rools/base'
 module Rools
   
   # The DefaultParameterProc binds to a Rule and
   # is allows the block to use method_missing to
   # refer to the asserted object.
-  class DefaultParameterProc
+  class DefaultParameterProc < Base
     
     # Determines whether a method is vital to the functionality
     # of the class.
@@ -44,7 +45,21 @@ 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}"
+      # 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
+        else
+          #puts "#{sym} not in facts"
+        end
+      rescue Exception => e
+        logger.error "miss exception #{e} #{e.backtrace.join("\n")}" if logger
+      end
       return @working_object if @working_object && args.size == 0
+      return nil
     end
     
     # Stops the current assertion. Does not indicate failure.

data/lib/rools/facts.rb

@@ -0,0 +1,15 @@
+require 'rools/errors'
+require 'rools/default_parameter_proc'
+require 'rools/base'
+
+module Rools
+  class Facts < Base
+    attr_reader :name, :fact_value
+    
+    def initialize(rule_set, name, b)
+      @name = name
+      @fact_value = instance_eval( &b )
+      logger.debug "New Facts: #{@fact_value}" if logger
+    end
+  end
+end

data/lib/rools/rule.rb

@@ -1,21 +1,23 @@
 require 'rools/errors'
 require 'rools/default_parameter_proc'
+require 'rools/base'
 
 module Rools
-  class Rule
-    attr_reader :name
+  class Rule < Base
+    attr_reader :name, :priority, :rule_set
+   
     
     # A Rule requires a Rools::RuleSet, a name, and an associated block
     # which will be executed at initialization
-    def initialize(rule_set, name, b)
+    def initialize(rule_set, name, priority, b)
       @rule_set = rule_set
-      @name = name
-      
-      @conditions = []
+      @name     = name
+      @priority = priority
+      @conditions   = []
       @consequences = []
-      @parameters = []
+      @parameters   = []
       
-      instance_eval(&b)
+      instance_eval(&b) if b
     end
     
     # Adds a condition to the Rule.
@@ -63,9 +65,11 @@ 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
         if p.is_a?(Symbol)
           return false unless 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)
         end
       end
@@ -79,6 +83,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
         raise RuleCheckError.new(self, e)
       end
       
@@ -113,5 +118,9 @@ module Rools
     def fail(message = nil)
       @rule_set.fail(message)
     end
+    
+    def to_s
+      @name
+    end
   end
 end

data/lib/rools/rule_set.rb

@@ -1,26 +1,106 @@
 require 'rools/errors'
 require 'rools/rule'
+require 'rools/base'
+require 'rools/facts'
+require 'rools/csv_table'
+
+require 'rexml/document'
 
 module Rools
-  class RuleSet
-  
+  class RuleSet < Base
+    attr_reader :num_executed, :num_evaluated, :facts
+    
     PASS = :pass
     FAIL = :fail
     
+  
     # You can pass a set of Rools::Rules with a block parameter,
     # or you can pass a file-path to evaluate.
     def initialize(file = nil, &b)
       
       @rules = {}
+      @facts = {}
       @dependencies = {}
       
       if block_given?
         instance_eval(&b)
       else
-        instance_eval(File::open(file).read)
-      end
+        # loading a file, check extension
+        name,ext = file.split(".")
+        logger.debug("loading ext: #{ext}") if logger
+        case ext
+          when 'csv'
+            load_csv( file )
+            
+          when 'xml'
+            load_xml( file )
+            
+          when 'rb'
+            load_rb( file )
+              
+          when 'rules'  # for backwards compatibility
+            load_rb(file)
+            
+          else
+            raise "invalid file extension: #{ext}"
+        end
+       end
     end		
     
+    #
+    # Loads decision table
+    #
+    def load_csv( file )
+      csv = CsvTable.new( file )
+      logger.debug "csv rules: #{csv.rules}" if logger
+      instance_eval(csv.rules)
+    end
+    
+    #
+    # 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
+        }
+      }
+    end
+    
+    #
+    # Ruby File format
+    #
+    def load_rb( file )
+      instance_eval(File::open(file).read)
+    end
+    
+    def get_facts
+      @facts
+    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.
@@ -29,11 +109,38 @@ module Rools
     #     condition { language.name.downcase == 'ruby' }
     #     consequence { "#{language.name} is the best!" }
     #   end
-    def rule(name, &b)
+    def rule(name, priority=0, &b)
       name.to_s.downcase!
-      @rules[name] = Rule.new(self, name, b)
+      @rules[name] = Rule.new(self, name, priority, b)
     end
     
+    # 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
+    #
+	# rules.assert 'France'
+    #
+    def facts(name, &b)
+      name.to_s.downcase!
+      @facts[name] = Facts.new(self, name, b)
+    end
+    
+    
     # Use in conjunction with Rools::RuleSet#with to create a Rools::Rule dependent on
     # another. Dependencies are created through names (converted to
     # strings and downcased), so lax naming can get you into trouble with
@@ -72,6 +179,8 @@ module Rools
     def assert(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) }
@@ -84,12 +193,15 @@ module Rools
           
           # 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
@@ -104,7 +216,9 @@ module Rools
                 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
@@ -113,6 +227,7 @@ module Rools
             rescue RuleCheckError => e
               # log da error or sumpin
               available_rules.delete(e.rule)
+              @status = fail
             end # begin/rescue
             
           end # available_rules.each
@@ -122,12 +237,13 @@ module Rools
       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
+      return @status
     end # def assert
     
   end # class RuleSet

data/lib/rools/version.rb

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

metadata

@@ -1,53 +1,64 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.9.2
 specification_version: 1
 name: rools
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
-date: 2005-12-14
+  version: 0.1.5
+date: 2007-04-27 00:00:00 -04:00
 summary: A Rules Engine written in Ruby
 require_paths: 
-  - lib
-email: ssmoot@gmail.com; bauer.mail@gmail.com
-homepage: http://substantiality.net
+- lib
+email: ssmoot@gmail.com; bauer.mail@gmail.com cappelaere@gmail.com
+homepage: http://rools.rubyforge.org/
 rubyforge_project: rools
-description: "Can be used for program-flow, ideally suited to processing applications"
+description: Can be used for program-flow, ideally suited to processing applications
 autorequire: rools
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
-  - Sam Smoot
-  - Scott Bauer
+- Sam Smoot
+- Scott Bauer
+- Pat Cappelaere
 files: 
-  - README
-  - CHANGELOG
-  - RAKEFILE
-  - lib/rools.rb
-  - lib/rools/default_parameter_proc.rb
-  - lib/rools/errors.rb
-  - lib/rools/rule.rb
-  - lib/rools/rule_set.rb
+- README
+- CHANGELOG
+- RAKEFILE
+- lib/rools.rb
+- lib/rools/base.rb
+- lib/rools/csv_table.rb
+- lib/rools/default_parameter_proc.rb
+- lib/rools/errors.rb
+- lib/rools/facts.rb
+- lib/rools/rule.rb
+- lib/rools/rule_set.rb
+- lib/rools/version.rb
 test_files: []
+
 rdoc_options: 
-  - "--line-numbers"
-  - "--inline-source"
-  - "--main"
-  - README
+- --line-numbers
+- --inline-source
+- --main
+- README
 extra_rdoc_files: 
-  - README
-  - CHANGELOG
-  - RAKEFILE
+- README
+- CHANGELOG
+- RAKEFILE
 executables: []
+
 extensions: []
+
 requirements: 
-  - none
-dependencies: []
+- none
+dependencies: []
+