rufus-decision 1.0 → 1.1.0

data/CHANGELOG.txt

@@ -1,7 +1,21 @@
 
 = rufus-decision CHANGELOG.txt
 
-== rufus-decision - 0.10    released 2008/09/01
+
+== rufus-decision - 1.1    released 2009/04/25
+
+- todo #25670 : :ruby_eval settable at table initialization
+- todo #25667 : :ignore_case, :through and :accumulate settable at table
+                initialization (instead of only in the csv table itself)
+- todo #25647 : now accepts horizontal and vertical decision tables
+- todo #25642 : introducing bin/rufus_decided -t table.csv -i input.csv
+- todo #25629 : implemented Rufus::Decision.transpose(a)
+- todo #25630 : made Ruby 1.9.1 compatible
+- todo #25595 : Rufus::DecisionTable -> Rufus::Decision::Table
+- bug  #25589 : fixed issue with empty values and in:ranges
+
+
+== rufus-decision - 1.0    released 2008/09/01
 
 - todo #20670 : dropped rufus-eval in favour of rufus-treechecker
 

data/README.txt

@@ -4,7 +4,7 @@
 
 == getting it
 
-    sudo gem install -y rufus-decision
+  sudo gem install -y rufus-decision
 
 or at
 
@@ -13,15 +13,15 @@ http://rubyforge.org/frs/?group_id=4812
 
 == usage
 
+more info at http://rufus.rubyforge.org/rufus-decision/classes/Rufus/Decision/Table.html, but here is a recap.
+
 An example where a few rules determine which salesperson should interact with a customer with given characteristics.
 
 
-    require 'rubygems'
-    require 'rufus/decision'
-    
-    include Rufus
-    
-    TABLE = DecisionTable.new("""
+  require 'rubygems'
+  require 'rufus/decision'
+  
+  TABLE = Rufus::Decision::Table.new(%{
     in:age,in:trait,out:salesperson
     
     18..35,,adeslky
@@ -33,52 +33,85 @@ An example where a few rules determine which salesperson should interact with a
     25..35,rich,kerfelden
     ,cheerful,swanson
     ,maniac,korolev
-    """)
-    
-    #
-    # Given a customer (a Hash instance directly, for 
-    # convenience), returns the name of the first 
-    # corresponding salesman.
-    #
-    def determine_salesperson (customer)
-    
-        TABLE.transform(customer)["salesperson"]
-    end
-    
-    puts determine_salesperson(
-        "age" => 72)
-        # => thorsten
-    
-    puts determine_salesperson(
-        "age" => 25, "trait" => "rich")
-        # => adeslky
-    
-    puts determine_salesperson(
-        "age" => 23, "trait" => "cheerful")
-        # => adeslky
-    
-    puts determine_salesperson(
-        "age" => 25, "trait" => "maniac")
-        # => adeslky
-    
-    puts determine_salesperson(
-        "age" => 44, "trait" => "maniac")
-        # => espadas
-
-
-More at Rufus::DecisionTable
-
-
-= dependencies
-
-The gem 'rufus-dollar' (http://rufus.rubyforge.org/rufus-dollar) and the 'rufus-eval' gem (http://rufus.rubyforge.org/rufus-eval).
+  })
+  
+  # Given a customer (a Hash instance directly, for 
+  # convenience), returns the name of the first 
+  # corresponding salesman.
+  #
+  def determine_salesperson (customer)
+  
+    TABLE.transform(customer)["salesperson"]
+  end
+  
+  puts determine_salesperson(
+    "age" => 72) # => thorsten
+  
+  puts determine_salesperson(
+    "age" => 25, "trait" => "rich") # => adeslky
+  
+  puts determine_salesperson(
+    "age" => 23, "trait" => "cheerful") # => adeslky
+  
+  puts determine_salesperson(
+    "age" => 25, "trait" => "maniac") # => adeslky
+  
+  puts determine_salesperson(
+    "age" => 44, "trait" => "maniac") # => espadas
+
+
+More at Rufus::Decision::Table
+
+Note that you can use a CSV table served over HTTP like in :
+
+  
+  require 'rubygems'
+  require 'rufus/decision'
+  
+  TABLE = Rufus::DecisionTable.new(
+    'http://spreadsheets.google.com/pub?key=pCkopoeZwCNsMWOVeDjR1TQ&output=csv')
+  
+  # the CSV is :
+  #
+  # in:weather,in:month,out:take_umbrella?
+  #
+  # raining,,yes
+  # sunny,,no
+  # cloudy,june,yes
+  # cloudy,may,yes
+  # cloudy,,no
+  
+  def take_umbrella? (weather, month=nil)
+    h = TABLE.transform('weather' => weather, 'month' => month)
+    h['take_umbrella?'] == 'yes'
+  end
+  
+  puts take_umbrella?('cloudy', 'june')
+    # => true
+  
+  puts take_umbrella?('sunny', 'june')
+    # => false
+
+In this example, the CSV table is the direction CSV representation of the Google spreadsheet at : http://spreadsheets.google.com/pub?key=pCkopoeZwCNsMWOVeDjR1TQ
+
+WARNING though : use at your own risk. CSV loaded from untrusted locations may contain harmful code. The rufus-decision gem has an abstract tree checker integrated, it will check all the CSVs that contain calls in Ruby and raise a security error when possibly harmful code is spotted. Bullet vs Armor. Be warned.
+
+
+== uninstalling it
+
+    sudo gem uninstall -y rufus-decision
+
+
+== dependencies
+
+The gem 'rufus-dollar' (http://rufus.rubyforge.org/rufus-dollar) and the 'rufus-treechecker' gem (http://rufus.rubyforge.org/rufus-treechecker).
 
 
 == mailing list
 
-On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
+On the rufus-ruby list :
 
-    http://groups.google.com/group/rufus-ruby
+http://groups.google.com/group/rufus-ruby
 
 
 == irc
@@ -95,7 +128,7 @@ http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
 
 http://github.com/jmettraux/rufus-decision
 
-    git clone git://github.com/jmettraux/rufus-decision.git
+  git clone git://github.com/jmettraux/rufus-decision.git
 
 
 == author

data/bin/rufus_decide

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib') \
+  if File.exist?(File.dirname(__FILE__) + '/../lib/rufus')
+    # in dev mode, use the local rufus/decision
+
+require 'rubygems'
+require 'rufus/decision'
+
+rest = []
+opts = {}
+while arg = ARGV.shift do
+  if arg.match(/^-/)
+    opts[arg] = (ARGV.first &&  ! ARGV.first.match(/^-/)) ? ARGV.shift : true
+  else
+    rest << arg
+  end
+end
+
+USAGE = %{
+
+  = #{File.basename(__FILE__)} -i input.csv -t table.csv
+
+  runs decision table 'table.csv' on input 'input.csv', outputs as CSV.
+
+  == for example
+
+  #{File.basename(__FILE__)} -i input.csv -t table.csv
+
+  == options
+
+  -v, --version     : print the version of itog.rb and exits
+  -h, --help        : print this help text and exits
+
+  -i, --input       : points to input file (mandatory)
+  -t, --table       : points to the decision table file (mandatory)
+
+  -r, --ruby        : output as a Ruby hash representation instead of CSV
+  -j, --json        : output as a JSON hash representation instead of CSV
+
+  -T, --through     : don't stop at first match, run each row
+  -I, --ignore-case : ignore case when comparing values for row matching
+  -A, --accumulate  : use with -t, each time a new match is made for an 'out',
+                      values are not overriden but gathered in an array
+  -R, --ruby-eval   : allow evaluation of embedded ruby code (potentially 
+                      harmful)
+
+  -g, --goal        : points to an ideal target CSV file
+                      (decision table testing)
+
+}
+
+if (opts['-h'] or opts['--help'])
+  puts USAGE
+  exit(0)
+end
+
+if (opts['-v'] or opts['--version'])
+  puts "rufus-decision #{Rufus::Decision::VERSION}"
+  exit(0)
+end
+
+ipath = opts['-i'] || opts['--input']
+tpath = opts['-t'] || opts['--table']
+gpath = opts['-g'] || opts['--goal']
+
+if ipath == nil or tpath == nil
+
+  puts
+  puts "  ** missing --input and/or --table parameter"
+  puts USAGE
+  exit(1)
+end
+
+#
+# load CSV files
+
+input = Rufus::Decision.csv_to_a(ipath)
+input = Rufus::Decision.transpose(input)
+
+params = {}
+params[:ignore_case] = opts['-I'] || opts['--ignore-case']
+params[:ruby_eval] = opts['-R'] || opts['--ruby-eval']
+params[:through] = opts['-T'] || opts['--through']
+params[:accumulate] = opts['-A'] || opts['--accumulate']
+
+table = Rufus::Decision::Table.new(tpath, params)
+
+goal = gpath ? Rufus::Decision.csv_to_a(gpath) : nil
+
+#
+# run the decision table for each input row
+
+output = input.inject([]) { |a, hash| a << table.transform(hash); a }
+
+if goal
+  #
+  # check if output matches 'goal'
+
+  puts
+
+  goal = Rufus::Decision.transpose(goal)
+
+  failures = []
+
+  goal.each_with_index do |hash, y|
+    if hash == output[y]
+      print '.'
+    else
+      print 'f'
+      failures << [ y, output[y], hash ]
+    end
+  end
+
+  puts
+
+  failures.each do |f|
+    row, output, expected = f
+    puts
+    puts "  at row #{row}, expected"
+    puts "    #{expected.inspect}"
+    puts "  but got"
+    puts "    #{output.inspect}"
+  end
+
+  puts "\n#{goal.size} rows, #{failures.size} failures"
+
+else
+  #
+  # print output
+
+  if opts['-j'] or opts['--json']
+
+    require 'json' # sudo gem install json
+    puts output.to_json
+
+  elsif opts['-r'] or opts['--ruby']
+
+    p output
+
+  else # CSV
+
+    output = Rufus::Decision.transpose(output)
+    output.each do |row|
+      puts row.join(',')
+    end
+  end
+end
+

data/lib/rufus/decision.rb

@@ -1,6 +1,5 @@
-#
 #--
-# Copyright (c) 2007-2008, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2007-2009, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -19,14 +18,10 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
-#++
 #
+# Made in Japan.
+#++
 
-#
-# "made in Japan"
-#
-# John Mettraux at openwfe.org
-#
 
 require 'csv'
 require 'open-uri'
@@ -38,17 +33,9 @@ require 'rufus/hashes'
 
 
 module Rufus
+module Decision
 
-
-  #
-  # Does s starts with prefix ?
-  #
-  def Rufus.starts_with? (s, prefix)
-
-    return false unless s
-    (s[0, prefix.length] == prefix)
-  end
-
+  VERSION = '1.1.0'
 
   #
   # A decision table is a description of a set of rules as a CSV (comma
@@ -92,7 +79,9 @@ module Rufus
   #
   # Enough words, some code :
   #
-  #   table = DecisionTable.new("""
+  #   require 'rufus/decision'
+  #
+  #   table = Rufus::Decision::Table.new(%{
   #     in:topic,in:region,out:team_member
   #     sports,europe,Alice
   #     sports,,Bob
@@ -103,12 +92,12 @@ module Rufus
   #     politics,america,Gilbert
   #     politics,,Henry
   #     ,,Zach
-  #   """)
+  #   })
   #
   #   h = {}
   #   h["topic"] = "politics"
   #
-  #   table.transform! h
+  #   table.transform!(h)
   #
   #   puts h["team_member"]
   #     # will yield "Henry" who takes care of all the politics stuff,
@@ -116,20 +105,19 @@ module Rufus
   #
   # '>', '>=', '<' and '<=' can be put in front of individual cell values :
   #
-  #   table = DecisionTable.new("""
+  #   table = Rufus::Decision::Table.new(%{
   #     ,
   #     in:fx, out:fy
   #     ,
   #     >100,a
   #     >=10,b
   #     ,c
-  #   """)
+  #   })
   #
   #   h = { 'fx' => '10' }
-  #   table.transform! h
+  #   h = table.transform(h)
   #
-  #   require 'pp'; pp h
-  #     # will yield { 'fx' => '10', 'fy' => 'b' }
+  #   p h # => { 'fx' => '10', 'fy' => 'b' }
   #
   # Such comparisons are done after the elements are transformed to float
   # numbers. By default, non-numeric arguments will get compared as Strings.
@@ -142,9 +130,9 @@ module Rufus
   # hash.
   #
   #
-  # == Ruby ranges
+  # == [ruby] ranges
   #
-  # Ruby ranges are also accepted in cells.
+  # Ruby-like ranges are also accepted in cells.
   #
   #   in:f0,out:result
   #   ,
@@ -160,9 +148,9 @@ module Rufus
   # You can put options on their own in a cell BEFORE the line containing
   # "in:xxx" and "out:yyy" (ins and outs).
   #
-  # Currently, two options are supported, "ignorecase" and "through".
+  # Three options are supported, "ignorecase", "through" and "accumulate".
   #
-  # * "ignorecase", if found by the DecisionTable will make any match (in the
+  # * "ignorecase", if found by the decision table will make any match (in the
   #   "in" columns) case unsensitive.
   #
   # * "through", will make sure that EVERY row is evaluated and potentially
@@ -172,6 +160,8 @@ module Rufus
   # * "accumulate", behaves as with "through" set but instead of overriding
   #   values each time a match is found, will gather them in an array.
   #
+  # an example of 'accumulate'
+  #
   #   accumulate
   #   in:f0,out:result
   #   ,
@@ -181,11 +171,18 @@ module Rufus
   #
   #   will yield { result => [ 'normal', 'large' ]} for f0 => 56
   #
+  # === Setting options at table initialization
+  #
+  # It's OK to set the options at initialization time :
+  #
+  #   table = Rufus::Decision::Table.new(
+  #     csv, :ruby_eval => true, :accumulate => true)
+  #
   #
   # == Cross references
   #
   # By using the 'dollar notation', it's possible to reference a value
-  # already in the hash.
+  # already in the hash (that is, the hash undergoing 'transformation').
   #
   #   in:value,in:roundup,out:newvalue
   #   0..32,true,32
@@ -208,7 +205,7 @@ module Rufus
   # Note though that this feature is only enabled via the :ruby_eval
   # option of the transform!() method.
   #
-  #   decisionTable.transform! h, :ruby_eval => true
+  #   decisionTable.transform!(h, :ruby_eval => true)
   #
   # That decision table may look like :
   #
@@ -220,404 +217,419 @@ module Rufus
   # (It's a very simplistic example, but I hope it demonstrates the
   # capabilities of this technique)
   #
+  # It's OK to set the :ruby_eval parameter when initializing the decision
+  # table :
+  #
+  #   table = Rufus::Decision::Table.new(csv, :ruby_eval => true)
+  #
+  # so that there is no need to specify it at transform() call time.
+  #
   #
   # == See also
   #
   # * http://jmettraux.wordpress.com/2007/02/11/ruby-decision-tables/
   #
-  class DecisionTable
+  class Table
+
+    IN = /^in:/
+    OUT = /^out:/
+    IN_OR_OUT = /^(in|out):/
+    NUMERIC_COMPARISON = /^([><]=?)(.*)$/
 
-    #
     # when set to true, the transformation process stops after the
     # first match got applied.
     #
     attr_accessor :first_match
 
-    #
     # when set to true, matches evaluation ignores case.
     #
     attr_accessor :ignore_case
 
-    #
     # when set to true, multiple matches result get accumulated in
     # an array.
     #
     attr_accessor :accumulate
 
-    #
     # The constructor for DecisionTable, you can pass a String, an Array
     # (of arrays), a File object. The CSV parser coming with Ruby will take
     # care of it and a DecisionTable instance will be built.
     #
-    def initialize (csv_data)
-
-      @first_match = true
-      @ignore_case = false
-      @accumulate = false
-
-      @header = nil
-      @rows = []
-
-      csv_array = to_csv_array(csv_data)
-
-      csv_array.each do |row|
+    # parameters (options) are :through, :ignore_case, :accumulate (which
+    # forces :through to true when set) and :ruby_eval. See
+    # Rufus::Decision::Table for more details.
+    #
+    def initialize (csv, params={})
 
-        next if empty_row? row
+      @first_match = (params[:through] != true)
+      @ignore_case = params[:ignore_case] || params[:ignorecase]
+      @accumulate = params[:accumulate]
+      @ruby_eval = params[:ruby_eval]
 
-        if @header
+      @first_match = false if @accumulate
 
-          @rows << row.collect { |c| c.strip if c }
-        else
+      @rows = Rufus::Decision.csv_to_a(csv)
 
-          parse_header_row row
-        end
-      end
+      extract_options
+      parse_header_row
     end
 
-    #
     # Like transform, but the original hash doesn't get touched,
     # a copy of it gets transformed and finally returned.
     #
     def transform (hash, options={})
 
-      transform! hash.dup, options
+      transform!(hash.dup)
     end
 
-    #
     # Passes the hash through the decision table and returns it,
     # transformed.
     #
     def transform! (hash, options={})
 
-      hash = Rufus::EvalHashFilter.new(hash) \
-        if options[:ruby_eval] == true
+      hash = Rufus::Decision::EvalHashFilter.new(hash) \
+        if @ruby_eval || options[:ruby_eval] == true
 
       @rows.each do |row|
-
-        if matches?(row, hash)
-
-          apply row, hash
-          break if @first_match
-        end
+        next unless matches?(row, hash)
+        apply(row, hash)
+        break if @first_match
       end
 
-      hash
+      hash.is_a?(Rufus::Decision::HashFilter) ? hash.parent_hash : hash
     end
 
-    #
+    alias :run :transform
+
     # Outputs back this table as a CSV String
     #
     def to_csv
 
-      s = ""
-      s << @header.to_csv
-      s << "\n"
-      @rows.each do |row|
-        s << row.join(",")
-        s << "\n"
-      end
-      s
+      a = [ @header.to_csv ]
+      @rows.inject(a) { |a, row| a << row.join(',') }.join("\n")
     end
 
     private
 
-      def parse_uri (string)
+    # Returns true if the hash matches the in: values for this row
+    #
+    def matches? (row, hash)
 
-        return nil if string.split("\n").size > 1
+      @header.ins.each do |x, in_header|
 
-        begin
-          return URI::parse(string)
-        rescue Exception => e
-        end
+        in_header = "${#{in_header}}"
 
-        nil
-      end
+        value = Rufus::dsub(in_header, hash)
 
-      def to_csv_array (csv_data)
+        cell = row[x]
 
-        return csv_data if csv_data.kind_of?(Array)
+        next if cell == nil || cell == ''
 
-        csv_data = csv_data.to_s if csv_data.is_a?(URI)
+        cell = Rufus::dsub(cell, hash)
 
-        csv_data = open(csv_data) if parse_uri(csv_data)
+        b = if m = NUMERIC_COMPARISON.match(cell)
+
+          numeric_compare(m, value, cell)
+        else
+
+          range = to_ruby_range(cell)
+          range ? range.include?(value) : regex_compare(value, cell)
+        end
 
-        CSV::Reader.parse csv_data
+        return false unless b
       end
 
-      def matches? (row, hash)
+      true
+    end
+
+    def regex_compare (value, cell)
 
-        return false if empty_row?(row)
+      modifiers = 0
+      modifiers += Regexp::IGNORECASE if @ignore_case
 
-        #puts
-        #puts "__row match ?"
-        #p row
+      rcell = Regexp.new(cell, modifiers)
+
+      rcell.match(value)
+    end
 
-        @header.ins.each_with_index do |in_header, icol|
+    def numeric_compare (match, value, cell)
 
-          in_header = resolve_in_header(in_header)
+      comparator = match[1]
+      cell = match[2]
 
-          value = Rufus::dsub in_header, hash
+      nvalue = Float(value) rescue value
+      ncell = Float(cell) rescue cell
 
-          cell = row[icol]
+      value, cell = if nvalue.is_a?(String) or ncell.is_a?(String)
+        [ "\"#{value}\"", "\"#{cell}\"" ]
+      else
+        [ nvalue, ncell ]
+      end
 
-          next if not cell
+      s = "#{value} #{comparator} #{cell}"
 
-          cell = cell.strip
+      Rufus::Decision::check_and_eval(s) rescue false
+    end
 
-          next if cell.length < 1
+    def apply (row, hash)
 
-          cell = Rufus::dsub cell, hash
+      @header.outs.each do |x, out_header|
 
-          #puts "__does '#{value}' match '#{cell}' ?"
+        value = row[x]
 
-          c = cell[0, 1]
+        next if value == nil || value == ''
 
-          b = if c == '<' or c == '>'
+        value = Rufus::dsub(value, hash)
 
-            numeric_compare value, cell
-          else
+        hash[out_header] = if @accumulate
+          #
+          # accumulate
 
-            range = to_ruby_range cell
+          v = hash[out_header]
 
-            if range
-              range.include?(value)
-            else
-              regex_compare value, cell
-            end
+          if v and v.is_a?(Array)
+            v + Array(value)
+          elsif v
+            [ v, value ]
+          else
+            value
           end
+        else
+          #
+          # override
 
-          return false unless b
+          value
         end
+      end
+    end
 
-        #puts "__row matches"
+    def extract_options
 
-        true
-      end
+      row = @rows.first
 
-      def regex_compare (value, cell)
+      return unless row
+        # end of table somehow
 
-        modifiers = 0
-        modifiers += Regexp::IGNORECASE if @ignore_case
+      return if row.find { |cell| cell && cell.match(IN_OR_OUT) }
+        # just hit the header row
 
-        rcell = Regexp.new(cell, modifiers)
+      row.each do |cell|
 
-        rcell.match(value)
-      end
+        cell = cell.downcase
 
-      def numeric_compare (value, cell)
+        if cell == 'ignorecase' or cell == 'ignore_case'
+          @ignore_case = true
+        elsif cell == 'through'
+          @first_match = false
+        elsif cell == 'accumulate'
+          @first_match = false
+          @accumulate = true
+        end
+      end
 
-        comparator = cell[0, 1]
-        comparator += "=" if cell[1, 1] == "="
-        cell = cell[comparator.length..-1]
+      @rows.shift
 
-        nvalue = narrow(value)
-        ncell = narrow(cell)
+      extract_options
+    end
 
-        if nvalue.is_a? String or ncell.is_a? String
-          value = '"' + value + '"'
-          cell = '"' + cell + '"'
-        else
-          value = nvalue
-          cell = ncell
-        end
+    # Returns true if the first row of the table contains just an "in:" or
+    # an "out:"
+    #
+    def is_vertical_table? (first_row)
+      bin = false
+      bout = false
+      first_row.each do |cell|
+        bin ||= cell.match(IN)
+        bout ||= cell.match(OUT)
+        return false if bin and bout
+      end
+      true
+    end
 
-        s = "#{value} #{comparator} #{cell}"
+    def parse_header_row
 
-        #puts "...>>>#{s}<<<"
+      row = @rows.first
 
-        begin
-          return Rufus::check_and_eval(s)
-        rescue Exception => e
-        end
+      return unless row
 
-        false
+      if is_vertical_table?(row)
+        @rows = @rows.transpose
+        row = @rows.first
       end
 
-      def narrow (s)
-        begin
-          return Float(s)
-        rescue Exception => e
-        end
-        s
+      @rows.shift
+
+      row.each_with_index do |cell, x|
+        next unless cell.match(IN_OR_OUT)
+        (@header ||= Header.new).add(cell, x)
       end
+    end
 
-      def resolve_in_header (in_header)
+    # A regexp for checking if a string is a numeric Ruby range
+    #
+    RUBY_NUMERIC_RANGE_REGEXP = Regexp.compile(
+      "^\\d+(\\.\\d+)?\\.{2,3}\\d+(\\.\\d+)?$")
 
-        "${#{in_header}}"
-      end
+    # A regexp for checking if a string is an alpha Ruby range
+    #
+    RUBY_ALPHA_RANGE_REGEXP = Regexp.compile(
+      "^([A-Za-z])(\\.{2,3})([A-Za-z])$")
 
-      def apply (row, hash)
+    # If the string contains a Ruby range definition
+    # (ie something like "93.0..94.5" or "56..72"), it will return
+    # the Range instance.
+    # Will return nil else.
+    #
+    # The Ruby range returned (if any) will accept String or Numeric,
+    # ie (4..6).include?("5") will yield true.
+    #
+    def to_ruby_range (s)
 
-        @header.outs.each_with_index do |out_header, icol|
+      range = if RUBY_NUMERIC_RANGE_REGEXP.match(s)
 
-          next unless out_header
+        eval(s)
 
-          value = row[icol]
+      else
 
-          next unless value
-          #next unless value.strip.length > 0
-          next unless value.length > 0
+        m = RUBY_ALPHA_RANGE_REGEXP.match(s)
 
-          value = Rufus::dsub value, hash
+        m ? eval("'#{m[1]}'#{m[2]}'#{m[3]}'") : nil
+      end
 
-          hash[out_header] = if @accumulate
-            #
-            # accumulate
+      class << range
 
-            v = hash[out_header]
-            if v and v.is_a?(Array)
-              v + Array(value)
-            elsif v
-              [ v, value ]
-            else
-              value
-            end
-          else
-            #
-            # override
+        alias :old_include? :include?
 
-            value
-          end
+        def include? (elt)
+
+          elt = first.is_a?(Numeric) ? (Float(elt) rescue '') : elt
+          old_include?(elt)
         end
-      end
 
-      def parse_header_row (row)
+      end if range
 
-        row.each_with_index do |cell, icol|
+      range
+    end
 
-          next unless cell
+    class Header
 
-          cell = cell.strip
-          s = cell.downcase
+      attr_accessor :ins, :outs
 
-          if s == "ignorecase" or s == "ignore_case"
-            @ignore_case = true
-            next
-          end
+      def initialize
 
-          if s == "through"
-            @first_match = false
-            next
-          end
+        @ins = {}
+        @outs = {}
+      end
 
-          if s == "accumulate"
-            @first_match = false
-            @accumulate = true
-            next
-          end
+      def add (cell, x)
 
-          if Rufus::starts_with?(cell, "in:") or \
-             Rufus::starts_with?(cell, "out:")
+        if cell.match(IN)
+
+          @ins[x] = cell[3..-1]
+
+        elsif cell.match(OUT)
+
+          @outs[x] = cell[4..-1]
 
-            @header = Header.new unless @header
-            @header.add cell, icol
-          end
         end
+        # else don't add
       end
 
-      def empty_row? (row)
+      def to_csv
 
-        return true unless row
-        return true if (row.length == 1 and not row[0])
-        row.each do |cell|
-          return false if cell
-        end
-        true
+        (@ins.keys.sort.collect { |k| "in:#{@ins[k]}" } +
+         @outs.keys.sort.collect { |k| "out:#{@outs[k]}" }).join(',')
       end
+    end
+  end
 
-      #
-      # A regexp for checking if a string is a numeric Ruby range
-      #
-      RUBY_NUMERIC_RANGE_REGEXP = Regexp.compile(
-        "^\\d+(\\.\\d+)?\\.{2,3}\\d+(\\.\\d+)?$")
-
-      #
-      # A regexp for checking if a string is an alpha Ruby range
-      #
-      RUBY_ALPHA_RANGE_REGEXP = Regexp.compile(
-        "^([A-Za-z])(\\.{2,3})([A-Za-z])$")
-
-      #
-      # If the string contains a Ruby range definition
-      # (ie something like "93.0..94.5" or "56..72"), it will return
-      # the Range instance.
-      # Will return nil else.
-      #
-      # The Ruby range returned (if any) will accept String or Numeric,
-      # ie (4..6).include?("5") will yield true.
-      #
-      def to_ruby_range (s)
-
-        range = if RUBY_NUMERIC_RANGE_REGEXP.match(s)
-
-          eval s
+  # Given a CSV string or the URI / path to a CSV file, turns the CSV
+  # into an array of array.
+  #
+  def self.csv_to_a (csv)
 
-        else
+    return csv if csv.is_a?(Array)
 
-          m = RUBY_ALPHA_RANGE_REGEXP.match(s)
+    csv = csv.to_s if csv.is_a?(URI)
+    csv = open(csv) if is_uri?(csv)
 
-          if m
-            eval "'#{m[1]}'#{m[2]}'#{m[3]}'"
-          else
-            nil
-          end
-        end
+    csv_lib = defined?(CSV::Reader) ? CSV::Reader : CSV
+      # no CSV::Reader for Ruby 1.9.1
 
-        class << range
+    csv_lib.parse(csv).inject([]) { |rows, row|
+      row = row.collect { |cell| cell ? cell.strip : '' }
+      rows << row if row.find { |cell| (cell != '') }
+      rows
+    }
+  end
 
-          alias :old_include? :include?
+  # Returns true if the string is a URI false if it's something else
+  # (CSV data ?)
+  #
+  def self.is_uri? (string)
 
-          def include? (elt)
+    return false if string.index("\n") # quick one
 
-            elt = if first.is_a?(Numeric)
-              Float(elt)
-            else
-              elt
-            end
+    begin
+      URI::parse(string); return true
+    rescue
+    end
 
-            old_include?(elt)
-          end
+    false
+  end
 
-        end if range
+  # Turns an array of array (rows / columns) into an array of hashes.
+  # The first row is considered the "row of keys".
+  #
+  #   [
+  #     [ 'age', 'name' ],
+  #     [ 33, 'Jeff' ],
+  #     [ 35, 'John' ]
+  #   ]
+  #
+  # =>
+  #
+  #  [
+  #    { 'age' => 33, 'name' => 'Jeff' },
+  #    { 'age' => 35, 'name' => 'John' }
+  #  ]
+  #
+  # You can also pass the CSV as a string or the URI/path to the actual CSV
+  # file.
+  #
+  def self.transpose (a)
 
-        range
-      end
+    a = csv_to_a(a) if a.is_a?(String)
 
-      class Header
+    return a if a.empty?
 
-        attr_accessor :ins, :outs
+    first = a.first
 
-        def initialize
+    if first.is_a?(Hash)
 
-          @ins = []
-          @outs = []
-        end
+      keys = first.keys.sort
+      [ keys ] + a.collect { |row|
+        keys.collect { |k| row[k] }
+      }
+    else
 
-        def add (cell, icol)
+      keys = first
+      a[1..-1].collect { |row|
+        (0..keys.size - 1).inject({}) { |h, i| h[keys[i]] = row[i]; h }
+      }
+    end
+  end
 
-          if Rufus::starts_with?(cell, "in:")
-            @ins[icol] = cell[3..-1]
-            #puts "i added #{@ins[icol]}"
-          elsif Rufus::starts_with?(cell, "out:")
-            @outs[icol] = cell[4..-1]
-            #puts "o added #{@outs[icol]}"
-          end
-          # else don't add
-        end
+end
+end
 
-        def to_csv
+module Rufus
 
-          s = ""
-          @ins.each do |_in|
-            s << "in:#{_in}," if _in
-          end
-          @outs.each do |out|
-            s << "out:#{out}," if out
-          end
-          s[0..-2]
-        end
-      end
+  #
+  # An 'alias' for the class Rufus::Decision::Table
+  #
+  # (for backward compatibility)
+  #
+  class DecisionTable < Rufus::Decision::Table
   end
-
 end