rfs 0.1 → 0.2

data/lib/innate/array.rb

@@ -10,76 +10,62 @@ class Array
   end
 
   def rows(width = 80, spaces = 2, spacer = ' ')
-    return '' if length == 0
-    best = nil
-    bestcw = nil
-    sorted = self # changed my mind: don't sort
-    
-    1.upto(width) do |columns|
-      space = spacer.length * spaces * (columns - 1)
-      break if columns + space > width
-      t = []
-      rows = []
-      cw = [0] * columns
-      result = sorted.each do |item|
-        if t.length == columns
-          break :fail unless check_cols cw, rows, t, width, space, columns
-          t = []
+    results = row_col(width, spaces, spacer) do |array, cols, empty_element, max|
+      r = []
+      stat = :ok
+      begin
+        s = array.slice!(0, cols)
+        if max
+          break :fail if :fail == s.inject(0) do |a, b| 
+            c = a + b
+            if c > max
+              stat = :fail
+              break :fail
+            else
+              c
+            end
+          end
         end
-        t << item.to_s
-      end
-      t += [''] * (columns - t.length)
-      unless result == :fail
-        result = :fail unless check_cols cw, rows, t, width, space, columns
-      end
-      if result != :fail
-        best = rows
-        bestcw = cw
+        r << s
+      end until array == []
+      next :fail if stat == :fail
+      l = r.last.length
+      if l == 0
+        r.pop
+      elsif l < cols
+        r.push(r.pop + [empty_element] * (cols - l))
       end
+      [r, r.transpose]
     end
-    fs = bestcw.collect {|w| "%#{w}-s" }.join(spacer * spaces)
-    best.collect {|row| format(fs, *row) }.join "\n"
+    row_col_format(spaces, spacer, *results)
   end
-
+  
   def columns(width = 80, spaces = 2, spacer = ' ')
-    return '' if length == 0
-    best = nil
-    bestcw = nil
-    sorted = self # changed my mind: don't sort
-
-    1.upto(width) do |columns|
-      space = spacer.length * spaces * (columns - 1)
-      rows = []
-      cols = []
-      cw = [0] * columns
-      col_len = length / columns
-      col_len += 1 if length > (columns * col_len)
-
-      temp = nil
-      if length % col_len > 0
-        temp = sorted + ([''] * (col_len - length % col_len))
-      else
-        temp = sorted
-      end
-        
-      columns.times do |c|
-        t = temp[(col_len * c)...(col_len * (c + 1))]
-        cols << t
+    results = row_col(width, spaces, spacer) do |array, cols, empty_element|
+      len = array.length
+      col_len = len / cols
+      if len > (cols * col_len)
+        col_len += 1
+        if col_len * cols - len >= col_len
+          fail = true
+          next :fail
+        end
       end
-      next if cols.last == [] or cols.last == nil
-
-      cols = cols.transpose
-      result = cols.each do |row|
-        break :fail unless check_cols cw, rows, row, width, space, columns
+      if len % col_len > 0
+        array += ([empty_element] * (col_len - length % col_len))
       end
-      if result != :fail
-        best = rows
-        bestcw = cw
+      col_data = []
+      cols.times do |c|
+        col_data << array.slice!(0, col_len)
       end
-      break if col_len == 1
-    end 
-    fs = bestcw.collect {|w| "%#{w}-s" }.join(spacer * spaces)
-    best.collect {|row| format(fs, *row) }.join "\n"
+      #if col_data.last == [] # or col_data.last == nil
+        ## shouldn't get here anymore...
+        #:fail
+      #else
+        [col_data.transpose, col_data]
+      #end
+    end
+    row_col_format(spaces, spacer, *results)
   end
   
   def pc(w = 130, s = 2, sr = ' ')
@@ -89,16 +75,39 @@ class Array
   def pr(w = 130, s = 2, sr = ' ')
     puts sort.rows(w, s, sr)
   end
-end
 
-#refactorings
-class Array
-private
-  def check_cols(cw, rows, t, width, space, columns)
-    idx = 0
-    cw.collect! {|w| r = (t[idx].length > w ? t[idx].length : w); idx += 1; r }
-    row_width = cw.inject(0){|tot, n| tot + n} + space
-    rows << t
-    (row_width < width) || columns == 1
+protected
+  def row_col(width, spaces, spacer)
+    return '', 1, [width] if length == 0
+    maxlen = 0
+    minlen = width
+    lengths = collect do |item| 
+      len = item.to_s.length
+      maxlen = len if len > maxlen
+      minlen = len if len < minlen
+      len
+    end
+    return self, 1, [width] if maxlen > width or length == 1
+    best_col_count = nil
+    best_col_widths = nil
+    max_possible_cols = width / (spaces * spacer.length + minlen) 
+    2.upto(max_possible_cols) do |column_count|
+      space = spacer.length * spaces * (column_count - 1)      
+      row_data, column_data = result = yield(lengths.clone, column_count, 0, width - space)
+      next if result == :fail
+      col_widths = column_data.collect {|col| col.max }
+      total_width = col_widths.inject(0) {|a, b| a + b} + space
+      if total_width <= width
+        best_col_count = column_count
+        best_col_widths = col_widths
+      end 
+    end
+    return yield(self.clone, best_col_count, '').first, best_col_count, best_col_widths
+  end 
+
+  def row_col_format(spaces, spacer, row_data, col_count, col_widths)
+    fs = col_widths.collect {|w| "%#{w}-s" }.join(spacer * spaces)
+    row_data.collect {|row| format(fs, *row).rstrip }.join("\n")
   end
+  
 end

data/lib/innate/filelines.rb

@@ -1,5 +1,5 @@
 
-# load is not currently thread safe.
+# load is not currently thread safe because of the method of recursion protection used.
 class FileLines < Array
   def initialize(fn)
     @fn = fn

data/lib/innate/regexp.rb

@@ -70,11 +70,15 @@ class MatchData
   # Interpolates %n to the corresponding capture.
   def sub(repl, capture_num = 1)
     cn = capture_num || 1
-    t = repl.clone
+    replace_capture self[cn] ? cn : 0, interpolate(repl)
+  end
+
+  def interpolate(s)
+    t = s.clone
     to_a[1..-1].each_with_index do |m, i|
       t.gsub!("%#{i + 1}", m ? m : '')
     end
-    replace_capture self[cn] ? cn : 0, t
+    t
   end
 end
 

data/lib/innate/roman.rb

@@ -3,7 +3,7 @@ require 'innate/regexp'
 class Regexp
   # All groups are non-capturing!
   def self.ROMAN_PATTERN
-    '(?:M{0,4})(?:C[DM]|D?C{0,3})(?:X[LC]|L?X{0,3})(?:I[VX]|V?I{0,3})'
+    '(?=[MCDLXVI])(?:M{0,4})(?:C[DM]|D?C{0,3})(?:X[LC]|L?X{0,3})(?:I[VX]|V?I{0,3})'
   end
 
   def self.ROMAN
@@ -16,7 +16,8 @@ class Regexp
   end
 end
 
-
+class RomanNumeralError < RuntimeError
+end
 
 class String
   def roman_numeral?
@@ -32,7 +33,7 @@ class String
   end
   
   def roman_to_i
-    raise "#{self} is not a valid roman numeral." unless roman_numeral?
+    raise RomanNumeralError.new("#{self} is not a valid roman numeral.") unless roman_numeral?
     s = upcase
     values = { ?M => 1000, ?D => 500, ?C => 100, ?L => 50, ?X => 10, ?V => 5, ?I => 1 }
     value = result = 0
@@ -47,8 +48,8 @@ end
 
 class Fixnum
   def roman
-    raise 'There is no Roman representation for numbers below 1.' if self < 1
-    raise 'There is no Roman representation for numbers above 4999.' if self > 4999
+    raise RomanNumeralError.new('There is no Roman representation for numbers below 1.') if self < 1
+    raise RomanNumeralError.new('There is no Roman representation for numbers above 4999.') if self > 4999
     elements = {1000 => 'M',500 => 'D',100 => 'C',50 => 'L',10 => 'X',5 => 'V',1 => 'I'}
     values = [1000, 500, 100, 50, 10, 5, 1]
     r = ''

data/lib/innate/test/testarray.rb

@@ -1,5 +1,6 @@
 require 'test/unit'
 require 'innate/array'
+require 'cursor/indexed'
 
 class TestArray < Test::Unit::TestCase
   def test_match_string
@@ -35,26 +36,29 @@ class TestArray < Test::Unit::TestCase
     to_r                      to_s           to_sym        truncate               type                   untaint
     upto                      zero?          |             ~}
     
-    s = "%                         &              *             **                     +                      +@                    \n" +
-        "-                         -@             /             <                      <<                     <=                    \n" +
-        "<=>                       ==             ===           =~                     >                      >=                    \n" +
-        ">>                        []             ^             __id__                 __send__               abs                   \n" +
-        "between?                  ceil           chr           class                  clone                  coerce                \n" +
-        "denominator               display        div           divmod                 downto                 dup                   \n" +
-        "eql?                      equal?         extend        floor                  freeze                 frozen?               \n" +
-        "gcd                       gcd2           gcdlcm        hash                   id                     id2name               \n" +
-        "inspect                   instance_eval  instance_of?  instance_variable_get  instance_variable_set  instance_variables    \n" +
-        "integer?                  is_a?          kind_of?      lcm                    method                 methods               \n" +
-        "modulo                    next           nil?          nonzero?               numerator              object_id             \n" +
-        "power!                    prec           prec_f        prec_i                 private_methods        protected_methods     \n" +
-        "public_methods            quo            rdiv          remainder              require                require_gem           \n" +
-        "require_gem_with_options  respond_to?    round         rpower                 send                   singleton_method_added\n" +
-        "singleton_methods         size           step          succ                   taint                  tainted?              \n" +
-        "times                     to_a           to_bn         to_f                   to_i                   to_int                \n" +
-        "to_r                      to_s           to_sym        truncate               type                   untaint               \n" +
-        "upto                      zero?          |             ~                                                                   "
+    s = ["%                         &              *             **                     +                      +@\n",
+        "-                         -@             /             <                      <<                     <=\n",
+        "<=>                       ==             ===           =~                     >                      >=\n",
+        ">>                        []             ^             __id__                 __send__               abs\n",
+        "between?                  ceil           chr           class                  clone                  coerce\n",
+        "denominator               display        div           divmod                 downto                 dup\n",
+        "eql?                      equal?         extend        floor                  freeze                 frozen?\n",
+        "gcd                       gcd2           gcdlcm        hash                   id                     id2name\n",
+        "inspect                   instance_eval  instance_of?  instance_variable_get  instance_variable_set  instance_variables\n",
+        "integer?                  is_a?          kind_of?      lcm                    method                 methods\n",
+        "modulo                    next           nil?          nonzero?               numerator              object_id\n",
+        "power!                    prec           prec_f        prec_i                 private_methods        protected_methods\n",
+        "public_methods            quo            rdiv          remainder              require                require_gem\n",
+        "require_gem_with_options  respond_to?    round         rpower                 send                   singleton_method_added\n",
+        "singleton_methods         size           step          succ                   taint                  tainted?\n",
+        "times                     to_a           to_bn         to_f                   to_i                   to_int\n",
+        "to_r                      to_s           to_sym        truncate               type                   untaint\n",
+        "upto                      zero?          |             ~"].to_cursor
+
+    a.rows(130, 2, ' ').each_line do |l|
+      assert_equal s.read1next, l
+    end
 
-    assert_equal s, a.rows(130, 2, ' ')
   end
 
   def test_columns
@@ -77,22 +81,54 @@ class TestArray < Test::Unit::TestCase
     to_r                      to_s           to_sym        truncate               type                   untaint
     upto                      zero?          |             ~}
     
-    s = "%    ===       clone        gcd                    kind_of?   private_methods           singleton_methods  to_sym  \n" +
-        "&    =~        coerce       gcd2                   lcm        protected_methods         size               truncate\n" +
-        "*    >         denominator  gcdlcm                 method     public_methods            step               type    \n" +
-        "**   >=        display      hash                   methods    quo                       succ               untaint \n" +
-        "+    >>        div          id                     modulo     rdiv                      taint              upto    \n" +
-        "+@   []        divmod       id2name                next       remainder                 tainted?           zero?   \n" +
-        "-    ^         downto       inspect                nil?       require                   times              |       \n" +
-        "-@   __id__    dup          instance_eval          nonzero?   require_gem               to_a               ~       \n" +
-        "/    __send__  eql?         instance_of?           numerator  require_gem_with_options  to_bn                      \n" +
-        "<    abs       equal?       instance_variable_get  object_id  respond_to?               to_f                       \n" +
-        "<<   between?  extend       instance_variable_set  power!     round                     to_i                       \n" +
-        "<=   ceil      floor        instance_variables     prec       rpower                    to_int                     \n" +
-        "<=>  chr       freeze       integer?               prec_f     send                      to_r                       \n" +
-        "==   class     frozen?      is_a?                  prec_i     singleton_method_added    to_s                       "
+    s = ["%    ===       clone        gcd                    kind_of?   private_methods           singleton_methods  to_sym\n",
+        "&    =~        coerce       gcd2                   lcm        protected_methods         size               truncate\n",
+        "*    >         denominator  gcdlcm                 method     public_methods            step               type\n",
+        "**   >=        display      hash                   methods    quo                       succ               untaint\n",
+        "+    >>        div          id                     modulo     rdiv                      taint              upto\n",
+        "+@   []        divmod       id2name                next       remainder                 tainted?           zero?\n",
+        "-    ^         downto       inspect                nil?       require                   times              |\n",
+        "-@   __id__    dup          instance_eval          nonzero?   require_gem               to_a               ~\n",
+        "/    __send__  eql?         instance_of?           numerator  require_gem_with_options  to_bn\n",
+        "<    abs       equal?       instance_variable_get  object_id  respond_to?               to_f\n",
+        "<<   between?  extend       instance_variable_set  power!     round                     to_i\n",
+        "<=   ceil      floor        instance_variables     prec       rpower                    to_int\n",
+        "<=>  chr       freeze       integer?               prec_f     send                      to_r\n",
+        "==   class     frozen?      is_a?                  prec_i     singleton_method_added    to_s"].to_cursor
+
+    a.columns(130, 2, ' ').each_line do |l|
+      assert_equal s.read1next, l
+    end
+  end
 
-    assert_equal s, a.columns(130, 2, ' ')
-  end     
+  def test_empty_array
+    a = []
+    assert_equal '', a.columns(80, 2, ' ')
+    assert_equal '', a.rows(80, 2, ' ')
+  end
+
+  def test_one_element
+    a = ['hello']
+    assert_equal 'hello', a.columns(80, 2, ' ')
+    assert_equal 'hello', a.rows(80, 2, ' ')
+  end
   
+  def test_long_element
+    a = ['hello', 'this is a rather long one']
+    assert_equal "hello\nthis is a rather long one", a.columns(15, 2, ' ')
+    assert_equal "hello\nthis is a rather long one", a.rows(15, 2, ' ')
+  end
+  
+  
+  def test_nil_array
+    a = [nil]
+    assert_equal '', a.columns(80, 2, ' ')
+    assert_equal '', a.rows(80, 2, ' ')
+  end
+
+  def test_array_with_nil
+    a = [1, nil, 3, nil]
+    assert_equal '1    3', a.columns(80, 2, ' ')
+    assert_equal '1    3', a.rows(80, 2, ' ')
+  end
 end

data/lib/innate/test/testroman.rb

@@ -50,5 +50,9 @@ class TestRoman < Test::Unit::TestCase
                  (/valiant(roman)soldier/i).interpolate_roman.to_s)
   end
 
+  def test_roman_regexp
+    assert_equal('mcmxiv', Regexp.new("(#{Regexp.ROMAN_PATTERN})", Regexp::IGNORECASE).match('the war of mcmxiv.')[1])
+  end
+
 end
 

data/lib/options.rb

@@ -28,37 +28,36 @@ module Options
   def opt(sym, *types)
     v = @options[sym]
     if v
-      unless types.empty?
-        if types.find {|t| v.is_a? t}
-          if block_given?
-            yield v
-          else
-            v
-          end
-        else
-          raise BadOptionValueError.new(sym, v.class, types)
-        end
-      else
-        if block_given?
-          yield v
-        else
-          v
-        end
+      if !types.empty? and !types.find {|t| v.is_a? t}
+        raise BadOptionValueError.new(sym, v.class, types)
       end
     elsif !types.include? NilClass
       raise MissingOptionError.new(sym)
     end
+    if block_given?
+      yield v
+    else
+      v
+    end
   end
 
   def opt_if(sym, *types)
-    begin
-      v = opt sym, *types
-    rescue OptionError
+    v = @options[sym]
+    r = if v
+      if types.empty?
+        :ok
+      elsif types.find {|t| v.is_a? t}
+        :ok
+      end
+    elsif types.include? NilClass
+      :ok
     end
-    if block_given?
-      yield v if v
-    else
-      v
+    if r == :ok
+      if block_given?
+        yield v
+      else
+        v
+      end
     end
   end
 end

data/lib/providers.rb

@@ -1,7 +1,8 @@
-
 module Provider
   module Folder
     class Tree
+      include Enumerable
+      
       def initialize(tree)
         @tree = tree
       end
@@ -25,6 +26,7 @@ module Provider
 
   module File
     class Base
+      attr_reader :folders
       def initialize(folder_provider)
         @folders = folder_provider
         @iterator = :each
@@ -72,6 +74,7 @@ module Provider
       end
     end
 
+    
     class Array < Base
       attr_accessor :files
 
@@ -87,6 +90,62 @@ module Provider
         end
       end
     end
+
+
+    ##I am decomissioning this code because
+    ##it did not result in any performance
+    ##improvement.  Upon profiling the program
+    ##it turns out (to my surprise) that
+    ##retrieving file listings was not a 
+    ##bottleneck at all.
+    #class Cache < Base
+      #def initialize(file_provider)
+        #@fp = file_provider
+        #reset_cache
+      #end
+
+      #def reset_cache
+        #@fg = Generator.new(@fp)
+        #@cache = []
+        #@cache_complete = false
+      #end
+      
+      #def each
+        #@cache.each do |a|
+          #yield a.first, a.last
+        #end
+        #unless @cache_complete
+          #while @fg.next?
+            #begin
+              #Thread.critical = true
+              #path, file = @fg.next
+              #@cache << [path, file]
+              #@cache_complete = true unless @fg.next?
+            #ensure
+              #Thread.critical = false
+            #end
+            #yield path, file
+          #end
+        #end
+      #end
+    #end
+    
+    
+    #class EnumerableFoldersCache < Cache
+      #def initialize(file_provider)
+        #@folders = []
+        #super
+      #end
+
+      #def each(&b)
+        #f = @fp.folders.collect
+        #unless f == @folders
+          #reset_cache
+          #@folders = f
+        #end
+        #super
+      #end
+    #end
   end
 end