facets 0.6.3

data/lib/facet-dev/string/pred.rb

@@ -0,0 +1,123 @@
+
+class String
+
+  # --- str.prev      => string
+  # Minimal difference previous.
+  # #prev is the essentially the opposite of #next. 
+  # #next and #prev are not exact opposites however,
+  # as some cases of #prev are indeterminate. In these
+  # cases #prev returns the minimal possible solution.
+  #
+  #   "123ABC".prev  #=> "123ABB"
+  #
+  # Credit goes to Pit Capitian.
+  # (The code could use some improving.)
+  def prev
+    case self
+    when ''
+      ''
+    when /[1-9B-Zb-z]/
+      alnum_pred
+    when /[0Aa].*[0Aa]/
+      alnum_pred
+    when /[0Aa]\000*$/
+      binary_pred
+    when /[0Aa]/
+      new_pred
+    else
+      binary_pred
+    end
+  end
+  
+  # ---- str.pred      => string
+  # Minimal difference predecessor. It is the essentially the opposite
+  # of #succ, althouth it is not the exact opposite. This version adds
+  # an optional paramter to specify the _n_th predecessor be returned
+  def pred(n=1)
+    s = self
+    n.times { s = s.prev }
+    s
+  end
+  
+  alias_method( :pred_once, :prev )
+  
+  private
+  
+    def alnum_pred
+      result = dup
+      zero_idx = last_idx = borrowed = borrowed_chars = nil
+      idx = size
+      while idx > 0
+        idx -= 1
+        last_idx = idx unless last_idx
+        case result[ idx ]
+        when ?1 .. ?9, ?B .. ?Z, ?b .. ?z
+          result[ idx ] -= 1
+          zero_idx = idx if result[ idx ] == ?0
+          borrowed = nil
+          break
+        when ?0
+          borrowed = result[ idx ] = ?9
+          borrowed_chars = 1
+        when ?A, ?a
+          result[ idx ] += ( ?Z - ?A )
+          zero_idx = idx
+          if borrowed == result[ idx ]
+            borrowed_chars -= 1
+          else
+            borrowed = result[ idx ]
+            borrowed_chars = 1
+          end
+        else
+          last_idx = nil if last_idx == idx
+        end
+      end
+      if borrowed && borrowed_chars > 0
+        result = new_pred
+      elsif zero_idx && zero_idx < last_idx
+        idx = 0
+        loop do
+          case result[ idx ]
+          when ?1 .. ?9, ?A .. ?Y, ?a .. ?y
+            break
+          when ?0, ?Z, ?z
+            result[ idx, 1 ] = '' if idx == zero_idx
+            break
+          else
+            idx += 1
+          end
+        end
+      end
+      result
+    end
+    
+    def binary_pred
+      result = dup
+      idx = size
+      while idx > 0
+        idx -= 1
+        if result[ idx ] > 0
+          result[ idx ] -= 1
+          break
+        else
+          result[ idx ] = 255
+        end
+      end
+      if idx == 0
+        case result[ idx ]
+        when 0
+          result[ 0, 1 ] = '' if size > 1
+        when 255
+          result = new_pred
+        end
+      end
+      result
+    end
+    
+    def new_pred
+      "new_pred " + self
+    end
+  
+end
+
+

data/lib/facet-dev/string/slash.rb

@@ -0,0 +1,15 @@
+#--
+# Credit goes to Paul Brannan <paul_at_atdesk.com>
+#++
+class String
+  # Allow easy manipulation of path strings.
+  #
+  #   require 'facet/string/slash'
+  #
+  #   prefix = '/usr' / 'local'  #=> "/usr/local"
+  #   prefix / 'bin'             #=> "/usr/local/bin"
+  #
+  def /(other)  #:infix:
+    File.join(self, other)
+  end
+end

data/lib/facet-dev/string/strip.rb

@@ -0,0 +1,32 @@
+# DEPRECATED AS USELESS!!! Use #lstrip and #rstrip instead.
+class String
+  # Return a new string with initial whitespace removed.
+  #
+  #   require 'facet/string/strip'
+  #
+  #   "  this   ".strip_first  #=> "this   "
+  #
+  def strip_first
+    self.gsub( /^\s*/, '' )
+  end
+  
+  # Like #strip_first, but modifies the string in place.
+  def strip_first!
+    self.gsub!( /^\s*/, '' )
+  end
+  
+  # Return a new string with final whitespace removed.
+  #
+  #   require 'facet/string/strip'
+  #
+  #   "  this   ".strip_last  #=> "   this"
+  #
+  def strip_last
+    self.gsub( /\s*$/, '' )
+  end
+  
+  # Like #strip_last, but modifies the string in place.
+  def strip_last!
+    self.gsub!( /\s*$/, '' )
+  end
+end

data/lib/facet-dev/string/succ_distance.rb

@@ -0,0 +1,112 @@
+class String
+
+  def distance_to(s)
+    return nil if not String === s
+    parts1 = split_parts
+    parts2 = s.split_parts
+    return nil if parts1.length != parts2.length
+    s1 = ""
+    s2 = ""
+    parts1.length.times do |pos|
+      return nil if parts1[pos].split_type != parts2[pos].split_type
+      if parts1[pos].split_type == :other
+        return nil if parts1[pos] != parts2[pos]
+      else
+        if s1.length != 0
+          return nil if parts1[pos].length > parts2[pos].length
+        else
+          parts1[pos] = case parts1[pos].split_type
+                        when :numeric
+                          "0"
+                        when :upper_case
+                          "\100"
+                        when :lower_case
+                          "\140"
+                        end * (parts2[pos].length - parts1[pos].length) + parts1[pos]
+        end
+        s1 << parts1[pos]
+        s2 << parts2[pos]
+      end
+    end
+    s2.split_value - s1.split_value
+  end
+
+  def <=>(s)
+    d = distance_to(s)
+    return nil if d.nil?
+    return 1 if d < 0
+    return -1 if d > 0
+    0
+  end
+
+  def split_parts
+    scan(/[0-9]+|[a-z]+|[A-Z]+|[^0-9a-zA-Z]+/)
+  end
+
+  def split_type
+    case self
+    when /[0-9]/
+      :numeric
+    when /[a-z]/
+      :lower_case
+    when /[A-Z]/
+      :upper_case
+    else
+      :other
+    end
+  end
+
+  def split_value
+    result = 0
+    each_byte do |b|
+      case b
+      when ?0..?9
+        result = result * 10 + b - ?0
+      when (?a-1)..?z
+        result = result * 26 + b - ?a
+      when (?A-1)..?Z
+        result = result * 26 + b - ?A
+      end
+    end
+    result
+  end
+
+  def succ(n=1)
+    result = self.dup
+    n.times {result.succ!}
+    result
+  end
+
+end
+
+
+# --- test ---
+
+if $0 == __FILE__
+
+  def try_it(a,b)
+    puts "#{a.distance_to(b)}, #{a <=> b}"
+  end
+  
+  a = "@#kF#9z4&&"
+  b = a.succ(2000000)
+  try_it(a,b)
+  
+  a = "a"
+  b = "a"
+  try_it(a,b)
+
+  a = "a"
+  b = "z"
+  try_it(a,b)
+
+  a = "A"
+  b = "Z"
+  try_it(a,b)
+
+  a = "a"
+  b = "Z"
+  try_it(a,b)
+
+end
+

data/lib/facet-dev/string/tc_pred.rb

@@ -0,0 +1,96 @@
+
+require 'test/unit'
+
+require 'facet/string/pred'
+
+
+class Pred_TC < Test::Unit::TestCase
+
+  def assert_pred( pred, str, msg = str )
+    assert_equal( pred, str.pred, "pred #{msg}" )
+  end
+
+  def assert_inverse( str, msg = str )
+    assert_equal( str, str.pred.succ, "inverse #{msg}" )
+  end
+
+  def assert_pred_with_inverse( pred, str, msg = str )
+    assert_pred( pred, str, msg )
+    assert_inverse( str, msg )
+  end
+
+  def test_01_empty
+    assert_pred_with_inverse( '', '', 'empty' )
+  end
+
+  def test_02_simple_alnum
+    assert_pred_with_inverse( '1', '2' )
+    assert_pred_with_inverse( '42', '43' )
+    assert_pred_with_inverse( '3999', '4000' )
+    assert_pred_with_inverse( '00399', '00400' )
+    assert_pred_with_inverse( 'A', 'B' )
+    assert_pred_with_inverse( 'HH', 'HI' )
+    assert_pred_with_inverse( 'AZZ', 'BAA' )
+    assert_pred_with_inverse( 'AAAZZ', 'AABAA' )
+    assert_pred_with_inverse( 'd', 'e' )
+    assert_pred_with_inverse( 'xx', 'xy' )
+    assert_pred_with_inverse( 'yzz', 'zaa' )
+    assert_pred_with_inverse( 'zzyzz', 'zzzaa' )
+    assert_pred_with_inverse( '8Z9z', '9A0a' )
+    assert_pred_with_inverse( ' /4-Z++9 $z #9#', ' /5-A++0 $a #0#' )
+  end
+
+  def test_03_leading_1Aa
+    assert_pred_with_inverse( '0', '1' )
+    assert_pred_with_inverse( '99', '100' )
+    assert_pred_with_inverse( '00099', '00100' )
+    assert_pred_with_inverse( 'Z', 'AA' )
+    assert_pred_with_inverse( 'zZz', 'aaAa' )
+    assert_pred_with_inverse( '9zZ', '10aA' )
+    assert_pred_with_inverse( 'Z9z9', 'AA0a0' )
+    assert_pred_with_inverse( ' /9-Z++9 $z #9#', ' /10-A++0 $a #0#' )
+  end
+
+  def test_04_illegal_alnum
+    assert_pred( 'new_pred 00', '00' )
+    assert_pred( 'new_pred 0000', '0000' )
+    assert_pred( 'new_pred A0', 'A0' )
+    assert_pred( 'new_pred 0a0', '0a0' )
+    assert_pred( 'new_pred 00Aa', '00Aa' )
+    assert_pred( 'new_pred aA', 'aA' )
+    assert_pred( 'new_pred Aa00', 'Aa00' )
+  end
+
+  def test_05_simple_binary
+    assert_pred_with_inverse( ' ', '!' )
+    assert_pred_with_inverse( '!$', '!%' )
+    assert_pred_with_inverse( "$\377\377\377", "%\000\000\000" )
+    assert_pred_with_inverse( "<==\377", "<=>\000" )
+    assert_pred_with_inverse( "\377 ", "\377!" )
+  end
+
+  def test_06_leading_001
+    assert_pred_with_inverse( "\000", "\001" )
+    assert_pred_with_inverse( "\377", "\001\000" )
+    assert_pred_with_inverse( "\377\377\377", "\001\000\000\000" )
+    assert_pred_with_inverse( "\000\000\377", "\000\001\000" )
+  end
+
+  def test_07_binary_with_0Aa
+    assert_pred_with_inverse( '/', '0' )
+    assert_pred_with_inverse( '@', 'A' )
+    assert_pred_with_inverse( '`', 'a' )
+    assert_pred_with_inverse( "$ @\377", "$ A\000" )
+    assert_pred_with_inverse( "+/\377\377", "+0\000\000" )
+  end
+
+  def test_08_illegal_binary
+    assert_pred( "new_pred \000", "\000" )
+    assert_pred( "new_pred \000\000", "\000\000" )
+    assert_pred( "new_pred 0\001", "0\001" )
+    assert_pred( "new_pred A+", "A+" )
+    assert_pred( "new_pred <a>", "<a>" )
+  end
+
+end
+ 

data/lib/facet-dev/string/word_wrap.rb

@@ -0,0 +1,62 @@
+class String
+  # Word wrap a string, not exceeding max width.
+  # This pads the end of each line with a space,
+  # or a hyphen if there was a word break. The margin
+  # determines how much play to give before forcing a
+  # word break.
+  #
+  # Note that this method reduces paragraphical
+  # whitespace down to a single space. If someone 
+  # sees to fix this, then more power to you!
+  def word_wrap(max_width=nil, margin=6)
+    max_width ||= 80
+    max_width -= 1
+    min_width = max_width - margin
+    blocks = []; scan(/(.*)(\n\s+\n|\Z)/m){ blocks << $~ }
+    complete = ''
+    blocks.each{ |block|
+      str = ''; line = ''
+      body = block[1].gsub(/\s+/, ' ')
+      padding = block[2].to_s
+      words = body.split(/\s+/)
+      i = 0
+      words.each { |word|
+        line << word
+        while line.length > max_width
+          clean_break = line.index(/\s\S*?$/)
+          clean_break = 0 unless clean_break
+          if clean_break < min_width
+            remaining = line[max_width..-1]
+            str << line.slice(0,max_width)
+            str << '-' if /^[a-zA-Z0-9]/ =~ remaining
+            str << "\n"
+            line = line[max_width..-1]
+          else
+            str << line.slice(0,clean_break)
+            str << " \n"
+            line = line[(clean_break + 1)..-1]
+          end
+        end
+        line << ' '
+      }
+      str << line.chomp(' ')
+      complete << str << padding
+    }  
+    complete << "\n"
+  end
+end
+
+
+# --- dev test ---
+
+if $0 == __FILE__
+
+s = "PackMule is a rake front-end thisisaverylongwordtoseeifgetsdivededornot"
+s << " tool that makes it easy to 'pack-out' your Ruby packages. PackMule can run tests, build"
+s << " .tgz and .zip packages, create gem packages, perform a manual"
+s << " install, generate rdocs and publish them, and CVS support"
+s << " might be added soon."
+
+puts s.word_wrap(60)
+
+end

data/lib/facet-dev/taint.rb

@@ -0,0 +1,10 @@
+$TAINT = {}
+module Kernel
+
+  #alias :req :require
+  def request( file, level )
+    $TAINT[file] = [Time.now, level]
+    require(file)
+  end
+
+end