facets 1.1.0 → 1.2.0

data/lib/facets/core/string/humanize.rb

@@ -0,0 +1,31 @@
+
+class String
+
+  # Replaces underscores with spaces and capitalizes word.
+  #
+  def humanize
+    self.gsub(/_/, " ").capitalize
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_humanize
+      assert_equal( 'This is it', 'this_is_it'.humanize )
+    end
+
+  end
+
+=end

data/lib/facets/core/string/indent.rb

@@ -0,0 +1,68 @@
+
+class String
+
+  # Aligns each line n spaces.
+  # (This used to be #taballto.)
+  #
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_tab
+      a = "xyz".tab(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+    def test_tabto
+      a = "xyz".tabto(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+    def test_indent
+      a = "xyz".indent(4)
+      assert_equal( '    ', a[0..3] )
+      # Need to expand on this
+    end
+
+  end
+
+=end

data/lib/facets/core/string/index_all.rb

@@ -0,0 +1,40 @@
+
+class String
+
+  # Like index but returns an array of all index locations.
+  # The reuse flag allows the trailing portion of a match to be 
+  # reused for subsquent matches.
+  #
+  #   "abcabcabc".index_all('a')  #=> [0,3,6]
+  #
+  def index_all(s, reuse=false)
+    ia = []; i = 0
+    while (i = self.index(s,i))
+      ia << i
+      i += (reuse ? 1 : $~.length)
+    end
+    ia
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_index_all
+      assert_equal( [0,4,8], "a123a567a9".index_all(/a/) )
+    end
+
+  end
+
+=end

data/lib/facets/core/string/last.rb

@@ -0,0 +1,94 @@
+
+require 'facet/string/self/patterns'
+require 'facet/string/shatter'
+require 'facet/string/first'
+
+class String
+
+  # Returns the last separation of a string.
+  # Default separation is by character.
+  #
+  #   "Hello World".last(' ')  #=> "World"
+  #
+  def last(separator_pattern=//)
+    pattern = self.class.patterns(separator_pattern)
+    self.split(separator_pattern).at(-1)
+  end
+
+  # Appends to a string.
+  #
+  #   "Hello World".last = ", Bye."  #=>  "Hello World, Bye."
+  #
+  def last=(str)
+    self << str
+  end
+
+  # Removes the last separation from a string.
+  # Default seperation is by characeter.
+  #--
+  # If a zero-length record separator is supplied,
+  # the string is split on /\n+/. If the record
+  # separator is set to <tt>nil</tt>, then the
+  # string is split on characters.
+  #++
+  #
+  #   a = "Hello World"
+  #   a.last!       #=> "d"
+  #   a             #=> "Hello Worl"
+  #
+  #   a = "Hello World"
+  #   a.last!(' ')  #=> "World"
+  #   a             #=> "Hello"
+  #
+  def last!(separator_pattern=//)
+    pattern = self.class.patterns(separator_pattern)
+    a = shatter(pattern)
+    r = a.last
+    a.pop
+    a.pop
+    replace( a.join('') )
+    return r
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_last
+      assert_equal( "z", "abcxyz".last )
+      assert_equal( "cz", "ax by cz".last(' ') )
+      assert_equal( "c", "a\nb\nc".last("\n") )
+    end
+
+    def test_last_eq
+      s = "abc"
+      s.last = "123"
+      assert_equal( "abc123", s )
+      s = "a\nbc"
+      s.last = "123"
+      assert_equal( "a\nbc123", s )
+    end
+
+    def test_last!
+      s = "abc"
+      s.last!
+      assert_equal( "ab", s )
+      s = "a b c"
+      s.last!(' ')
+      assert_equal( "a b", s )
+    end
+
+  end
+
+=end

data/lib/facets/core/string/last_char.rb

@@ -0,0 +1,22 @@
+require 'facet/string/first_char'
+
+class String
+  # Returns last _n_ characters.
+  #
+  #   "Hello World".last_char(3)  #=> "rld"
+  #
+  def last_char(n=1)
+    n = n.to_i
+    return self if n > size
+    slice(-n, n) #self[-n..-1]
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/facets/core/string/line_wrap.rb

@@ -0,0 +1,77 @@
+
+class String
+
+  # Line wrap at width.
+  #
+  #   puts "1234567890".line_wrap(5)
+  #
+  # _produces_
+  #
+  #   12345
+  #   67890
+  #
+  def line_wrap(width)
+    s = gsub(/\t/,' '*4) # tabs default to 4 spaces.
+    s = s.gsub(/\n/,' ')
+    r = s.scan( /.{1,#{width}}/ )
+    r.join("\n") << "\n"
+  end
+
+end
+
+# This is alternateive from glue: worth providing?
+
+  # Enforces a maximum width of a string inside an
+  # html container. If the string exceeds this maximum width
+  # the string gets wraped.
+  #
+  # Not really useful, better use the CSS overflow: hidden
+  # functionality.
+  #
+  # === Input:
+  # the string to be wrapped
+  # the enforced width
+  # the separator used for wrapping
+  #
+  # === Output:
+  # the wrapped string
+  #
+  # === Example:
+  #  text = "1111111111111111111111111111111111111111111"
+  #  text = wrap(text, 10, " ")
+  #  p text # => "1111111111 1111111111 1111111111"
+  #
+  # See the test cases to better understand the behaviour!
+
+#   def self.wrap(string, width = 20, separator = " ")
+#     return nil unless string
+#
+#     re = /([^#{separator}]{1,#{width}})/
+#     wrapped_string = string.scan(re).join(separator)
+#
+#     return wrapped_string
+#   end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_line_wrap
+      assert_equal "abc\n123\n", "abc123".line_wrap(3)
+      assert_equal "abcd\n123\n", "abcd123".line_wrap(4)
+    end
+
+  end
+
+=end

data/lib/facets/core/string/lines.rb

@@ -0,0 +1,33 @@
+
+class String
+
+  # Returns an array of characters.
+  #
+  #   "abc\n123".lines  #=> ["abc","123"]
+  #
+  def lines
+    self.split(/\n/)
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_lines
+      assert_equal( ['a','b','c'], "a\nb\nc".lines )
+    end
+
+  end
+
+=end

data/lib/facets/core/string/lowercase.rb

@@ -0,0 +1,32 @@
+#--
+# Credit goes to Phil Tomson.
+#++
+require 'facet/string/downcase'
+
+class String
+
+  # Alias for #downcase? method.
+  alias_method( :lowercase?, :downcase? )
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_lowercase?
+      assert( 'abc'.lowercase? )
+    end
+
+  end
+
+=end

data/lib/facets/core/string/margin.rb

@@ -0,0 +1,138 @@
+
+class String
+
+  # Provides a margin controlled string.
+  #
+  #   x = %Q{
+  #         | This
+  #         |   is
+  #         |     margin controlled!
+  #         }.margin
+  #
+  #--
+  # This may still need a bit of tweaking.
+  #++
+  def margin(n=0)
+    d = /\A.*\n\s*(.)/.match( self )[1]
+    d = /\A\s*(.)/.match( self)[1] unless d
+    return '' unless d
+    if n == 0
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+    else
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_margin
+
+      s = %q{
+            |ABC
+            |123
+            |TEST
+            }.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{
+              |ABC
+            |123
+                  |TEST
+            }.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{|ABC
+            |123
+            |TEST
+      }.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{
+            |ABC
+            |123
+            |TEST}.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{|ABC
+            |123
+            |TEST}.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{   |ABC
+            |123
+            |TEST}.margin
+      assert_equal( "ABC\n123\nTEST", s )
+
+      s = %q{ABC
+            |123
+            |TEST
+            }.margin
+      assert_equal( "ABC\n123\nTEST", s )
+    end
+
+    #
+
+    def test_spacing
+      s = %q{
+            | ABC
+            | 123
+            | TEST
+            }.margin
+      assert_equal( " ABC\n 123\n TEST", s )
+
+      s = %q{
+            |ABC
+            |123
+            |TEST
+            }.margin(1)
+      assert_equal( " ABC\n 123\n TEST", s )
+
+      s = %q{
+            |ABC
+            |123
+            |TEST
+            }.margin(2)
+      assert_equal( "  ABC\n  123\n  TEST", s )
+
+      s = %q{ ABC
+            - 123
+            - TEST
+            }.margin
+      assert_equal( " ABC\n 123\n TEST", s )
+
+    end
+
+    #
+
+    def test_random_placement
+      @volly = {}
+      100.times{ |n|
+        k = []
+        a = []
+        5.times{ |i|
+          k << ( ( ' ' * Integer(rand*10) ) + '|' + i.to_s )
+          a << ( i.to_s )
+        }
+        @volly[k.join("\n")] = a.join("\n")
+      }
+      @volly.each{ |k,v|
+        assert_equal( v, k.margin )
+      }
+    end
+
+  end
+
+=end