facets 0.9.0 → 1.0.0

data/lib/facet/string/rand_byte.rb

@@ -1 +1,55 @@
-require 'nano/string/rand_byte.rb'
+
+class String
+
+  # Return a random byte of _self_.
+  #
+  #   "Ruby rules".rand_byte  #=> 121
+  #
+  def rand_byte
+    self[rand( size )]
+  end
+
+  # Destructive rand_byte. Delete a random byte of _self_ and return it.
+  #
+  #   s = "Ruby rules"
+  #   s.rand_byte!      #=> 121
+  #   s                 #=> "Rub rules"
+  #
+  def rand_byte!
+    i = rand( size )
+    rv = self[i,1]
+    self[i,1] = ''
+    rv
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_rand_byte
+      s = 'ab'
+      r = s.rand_byte
+      assert( r == 97 || r == 98 )
+    end
+
+    def test_rand_byte
+      s = 'ab'
+      r = s.rand_byte
+      assert( r == 97 || r == 98 )
+      assert( s = 'a' || s = 'b' )
+    end
+
+  end
+
+=end

data/lib/facet/string/rand_index.rb

@@ -1 +1,29 @@
-require 'nano/string/rand_index.rb'
+class String
+  # Return a random string index.
+  #
+  #   "Ruby rules".rand_index  #=> 3
+  #
+  def rand_index
+    rand( size )
+  end
+end
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_rand_index
+      10.times { assert( (0..2).include?( 'abc'.rand_index ) ) }
+    end
+
+  end
+
+=end

data/lib/facet/string/range.rb

@@ -1 +1,37 @@
-require 'nano/string/range.rb'
+
+class String
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> 10..13
+  #
+  def range(s, offset=0)
+    if self.index(s, offset)
+      return ($~.begin(0))..($~.end(0)-1)
+    end
+    nil
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_range
+      assert_equal( (1..3), "a123a567a9".range(/123/) )
+      assert_equal( (0..0), "a123a567a9".range(/a/) )
+    end
+
+  end
+
+=end

data/lib/facet/string/range_all.rb

@@ -1 +1,48 @@
-require 'nano/string/range_all.rb'
+require 'facet/string/range'
+
+class String
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  #--
+  # Note: should add offset ?
+  #++
+  def range_all(s, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(s, i)
+      if rng
+        r << rng
+        i += reuse ? 1 : rng.end + 1
+      else
+        break
+      end
+    end
+    r.uniq
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_range_all
+      assert_equal( [ (1..3), (5..7) ], "a123a123a9".range_all(/123/) )
+      assert_equal( [ (0..0), (4..4), (8..8) ], "a123a567a9".range_all(/a/) )
+    end
+
+  end
+
+=end

data/lib/facet/string/range_of_line.rb

@@ -1 +1,42 @@
-require 'nano/string/range_of_line.rb'
+
+class String
+
+  # Returns an array of ranges mapping
+  # the characters per line.
+  #
+  #   "this\nis\na\ntest".range_of_line
+  #   #=> [0..4, 5..7, 8..9, 10..13]
+  #
+  def range_of_line
+    offset=0; charmap = []
+    self.each do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_range_of_line
+      a = "0123\n456\n78"
+      ltcm = a.range_of_line
+      assert_equal( [0..4, 5..8, 9..10], ltcm )
+    end
+
+  end
+
+=end

data/lib/facet/string/regesc.rb

@@ -0,0 +1,32 @@
+
+class String
+
+  # Escape string for Regexp use.
+  def regesc
+    Regexp.escape( self )
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_001
+      a = "?"
+      b = /#{a.regesc}/
+      assert( b =~ "?" )
+    end
+
+  end
+
+=end

data/lib/facet/string/self/format.rb

@@ -1 +1,17 @@
-require 'nano/string/self/format.rb'
+
+def String.format(*args)
+  Kernel.format(*args)
+end
+
+def String.sprintf(*args)
+  Kernel.format(*args)
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/facet/string/self/interpolate.rb

@@ -1 +1,31 @@
-require 'nano/string/self/interpolate.rb'
+
+class String
+
+  def self.interpolate(&str)
+    eval "%{#{str.call}}", str.binding
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_interpolate
+      a = 1
+      assert_equal('this is 1', String.interpolate{ 'this is #{a}' })
+    end
+
+  end
+
+=end

data/lib/facet/string/self/patterns.rb

@@ -1 +1,51 @@
-require 'nano/string/self/patterns.rb'
+class String
+
+  # Returns a Regexp pattern based on the given
+  # pattern string or symbolic name.
+  #
+  # Recognized names are:
+  #
+  # * :char
+  # * :word
+  # * :line
+  #
+  # They are also recognizied in plural form.
+  #
+  def self.patterns( pattern )
+    case pattern
+    when :char, :chars, :character, :characters
+      pattern = //
+    when :word, :words
+      pattern = /\s+|\Z/
+    when :line, :lines
+      pattern = /\Z/
+    when String
+      pattern = Regexp.new(Regexp.escape(pattern))
+    end
+    pattern
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_String_rand_letter
+      assert_equal( //, String.patterns(//) )
+      assert_equal( //, String.patterns(:chars) )
+      assert_equal( /\ /, String.patterns(' ') )
+    end
+
+  end
+
+=end

data/lib/facet/string/self/rand_letter.rb

@@ -1 +1,34 @@
-require 'nano/string/self/rand_letter.rb'
+class String
+
+  # Module method to generate a random letter.
+  #
+  #   String::Random.rand_letter  #=> "q"
+  #   String::Random.rand_letter  #=> "r"
+  #   String::Random.rand_letter  #=> "a"
+  #
+  def self.rand_letter
+    (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_String_rand_letter
+      100.times { |i| assert( /[a-zA-z]/ =~ String.rand_letter ) }
+    end
+
+  end
+
+=end

data/lib/facet/string/self/random.rb

@@ -1 +1,36 @@
-require 'nano/string/self/random.rb'
+#
+# Returns a randomly generated string. One possible use is
+# password initialization. Takes a max legnth of characters
+# (default 8) and an optional valid char Regexp (default /\w\d/).
+#
+#--
+#
+# Credit goes to George Moschovitis.
+#
+# :NOTE: This is not very efficient. Better way?
+#
+#++
+def String.random(max_length = 8, char_re = /[\w\d]/)
+  # gmosx: this is a nice example of input parameter checking.
+  # this is NOT a real time called method so we can add this
+  # check. Congrats to the author.
+  raise ArgumentError.new('char_re must be a regular expression!') unless char_re.is_a?(Regexp)
+
+  string = ""
+
+  while string.length < max_length
+      ch = rand(255).chr
+      string << ch if ch =~ char_re
+  end
+
+  return string
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/facet/string/shatter.rb

@@ -1 +1,45 @@
-require 'nano/string/shatter.rb'
+
+class String
+
+  # Breaks a string up into an array based on a regular expression.
+  # Similar to scan, but includes the matches.
+  #
+  #   s = "<p>This<b>is</b>a test.</p>"
+  #   s.shatter( /\<.*?\>/ )
+  #
+  # _produces_
+  #
+  #   ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+  #
+  def shatter( re )
+    r = self.gsub( re ){ |s| "\1" + s + "\1" }
+    while r[0,1] == "\1" ; r[0] = '' ; end
+    while r[-1,1] == "\1" ; r[-1] = '' ; end
+    r.split("\1")
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_shatter
+      s = "<p>This<b>is</b>a test.</p>"
+      sh = s.shatter( /<.*?>/ )
+      e = ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+      assert_equal(e, sh)
+    end
+
+  end
+
+=end