facets 3.0.0 → 3.1.0

data/demo/core/string/camelcase.md

@@ -0,0 +1,47 @@
+## String#Camelcase
+
+    require 'facets/string/camelcase'
+
+The `camelcase` method converts snakecase strings into camelcase strings.
+
+    "abc_xyz".camelcase.assert == "abcXyz"
+
+Continious underscore characters are treated as if a single underscore
+character.
+
+    "abc____xyz".camelcase.assert == "abcXyz"
+
+Without an argument the first character is left alone.
+
+    "Camel_case".camelcase.assert == "CamelCase"
+
+Passing +:upper+ or +true+ to #camelcase captializes the first letter.
+This is known as upper-camelcase.
+
+    "Abc_xyz".camelcase(true).assert == "AbcXyz"
+    "Abc____xyz".camelcase(:upper).assert == "AbcXyz"
+
+Where as passing +false+ or +:lower+ downcases the first character,
+known as lower-camelcase.
+
+    "abc_xyz".camelcase(false).assert == "abcXyz"
+    "abc____xyz".camelcase(false).assert == "abcXyz"
+    "Abc_xyz".camelcase(:lower).assert == "abcXyz"
+    "Abc____xyz".camelcase(:lower).assert == "abcXyz"
+
+By passing a match string to the method we can make +camelcase+ 
+apply to each word in a string.
+
+    "abc xyz".camelcase(' ').assert  == "abcXyz"
+    "abc  xyz".camelcase(/\s/).assert == "abcXyz"
+    "abc\txyz".camelcase(/\s/).assert == "abcXyz"
+    "abc\nxyz".camelcase(/\s/).assert == "abcXyz"
+
+## String#lower_camelcase
+
+    "abc_xyz".lower_camelcase.assert == "abcXyz"
+
+## String#upper_camelcase
+
+    "abc_xyz".upper_camelcase.assert == "AbcXyz"
+

data/demo/core/string/{capitalized.rdoc → capitalized.md}

@@ -1,27 +1,27 @@
-== String#capitalized?
+## String#capitalized?
 
 String#capitalized? return true if a string begins with a capitalized
 letter, false otherwise.
 
-  require 'facets/string/capitalized'
+    require 'facets/string/capitalized'
 
-  'Abc'.assert.capitalized?
+    'Abc'.assert.capitalized?
 
-== String#downcase?
+## String#downcase?
 
 In addition String#downcase? is provided which checks to see if the
 whole string is composed of lowercase letters.
 
-  'abc'.assert.downcase?
+    'abc'.assert.downcase?
 
-  #'abc'.assert.lowercase?
+    #'abc'.assert.lowercase?
 
-== String#upcase?
+## String#upcase?
 
 And String#upcase? which checks to see if the whole string is composed
 of uppercase letters.
 
-  'ABC'.assert.upcase?
+    'ABC'.assert.upcase?
 
-  #'ABC'.assert.uppercase?
+    #'ABC'.assert.uppercase?
 

data/demo/core/string/characters.md

@@ -0,0 +1,11 @@
+## String#characters
+
+The String#chars methods simply splits a string into
+an Array of character strings.
+
+    require 'facets/string/characters'
+
+    "abc".characters.assert == ["a","b","c"]
+
+    "ab\nc".characters.assert == ["a","b","\n","c"]
+

data/demo/core/string/{cleanlines.rdoc → cleanlines.md}

@@ -1,10 +1,10 @@
-== String#cleanlines
+## String#cleanlines
 
 Thre String#cleanlines method works essentially the same as String#lines,
 returning an Array of line strings, but it also removes trailing whitespace
 from each line.
 
-  require 'facets/string/cleanlines'
+    require 'facets/string/cleanlines'
 
-  "a \n b \nc".cleanlines.to_a.assert == ["a","b","c"]
+    "a \n b \nc".cleanlines.to_a.assert == ["a","b","c"]
 

data/demo/core/string/cleave.md

@@ -0,0 +1,49 @@
+## String#cleave
+
+    require 'facets/string/cleave'
+
+no spaces short word
+
+    s, x = 'whole', ['whole', '']
+    s.cleave.assert == x
+
+no spaces long word
+
+    s, x = 'Supercalifragilisticexpialidocious' , ['Supercalifragilisticexpialidocious', '']
+    s.cleave.assert == x
+
+exact middle two words
+
+    s, x = 'fancy split', ['fancy', 'split']
+    s.cleave.assert == x
+
+exact middle many words
+
+    s, x = 'All good Rubyists know how to party', ['All good Rubyists', 'know how to party']
+    s.cleave.assert == x
+
+closer to start
+
+    s, x = 'short splitter', ['short', 'splitter']
+    s.cleave.assert == x
+
+closer to start
+
+    s, x = 'Four score and seven years ago...', ['Four score and', 'seven years ago...']
+    s.cleave.assert == x
+
+closer to start
+
+    s, x = 'abc def ghijklm nop', ['abc def', 'ghijklm nop']
+    s.cleave.assert == x
+
+closer to end
+
+    s, x = 'extended split', ['extended', 'split']
+    s.cleave.assert == x
+
+closer to end
+
+    s, x = 'abc defghi jklm nop', [ 'abc defghi', 'jklm nop']
+    s.cleave.assert == x
+

data/demo/core/string/compress_lines.md

@@ -0,0 +1,22 @@
+## String#compress_lines
+
+    require 'facets/string/compress_lines'
+
+Matches any whitespace (including newline) at beginning and end of lines,
+and replaces with a single space.
+
+    string = <<-QUERY.compress_lines
+      SELECT name
+      FROM users
+    QUERY
+    string.assert == "SELECT name FROM users"
+
+Matches any whitespace (including newline) at beginning and end of lines,
+and removes it.
+
+    string = <<-QUERY.compress_lines(false)
+      SELECT name
+      FROM users
+    QUERY
+    string.assert == "SELECT nameFROM users"
+

data/demo/core/string/crypt.md

@@ -0,0 +1,15 @@
+## String#crypt
+
+    require 'facets/string/crypt'
+
+Adds a default salt to the built-in crypt method.
+
+NOTE: This method is not a common core extension and is not
+loaded automatically when using <code>require 'facets'</code>.
+
+     "abc".crypt('ZZ').assert.start_with?('ZZ')
+
+     encrypted = "abc".crypt
+     salt = encrypted[0..1]
+     "abc".crypt(salt).assert == encrypted
+

data/demo/core/string/divide.md

@@ -0,0 +1,9 @@
+## String#divide
+
+    require 'facets/string/divide'
+
+    s = "<p>This<b>is</b>a test.</p>"
+    d = s.divide(/<.*?>/)
+    e = ["<p>This", "<b>is", "</b>a test.", "</p>"]
+    d.assert == e
+

data/demo/core/string/each_word.md

@@ -0,0 +1,11 @@
+## String#each_word
+
+    require 'facets/string/each_word'
+
+    a = []
+    i = "this is a test"
+
+    i.each_word{ |w| a << w }
+
+    a.assert == ['this', 'is', 'a', 'test']
+

data/demo/core/string/edit_distance.md

@@ -0,0 +1,15 @@
+## String#edit_distance
+
+    require 'facets/string/edit_distance'
+
+Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.
+
+The Levenshtein distance is a measure of how similar two strings s and t are,
+calculated as the number of deletions/insertions/substitutions needed to
+transform s into t. The greater the distance, the more the strings differ.
+
+    d = "pretzel".edit_distance('pretzil')
+    d.assert = 1
+
+    d = "zretzel".edit_distance('pretzil')
+    d.assert = 2

data/demo/core/string/exclude.md

@@ -0,0 +1,15 @@
+## String#exclude?
+
+    require 'facets/string/exclude'
+
+The inverse of include?.
+
+    "aaaa".assert.exclude?('bb')
+    "aaab".assert.exclude?('bb')
+    "aaba".assert.exclude?('bb')
+    "baaa".assert.exclude?('bb')
+
+    "abba".refute.exclude?('bb')
+    "aabb".refute.exclude?('bb')
+    "bbaa".refute.exclude?('bb')
+

data/demo/core/string/expand_tabs.md

@@ -0,0 +1,69 @@
+## String#expand_tab
+
+    require 'facets/string/expand_tab'
+
+We will use this string as a basis for demonstration.
+
+    tabs = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    |\tOne tab
+    | \tOne space and one tab
+    |    \t Six spaces, a tab, and a space
+    EOF
+
+Expanding tabs 0.
+
+    expected = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    |One tab
+    | One space and one tab
+    |     Six spaces, a tab, and a space
+    EOF
+
+    tabs.expand_tabs(0).assert == expected
+
+Expanding tabs 1.
+
+    expected = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    | One tab
+    |  One space and one tab
+    |      Six spaces, a tab, and a space
+    EOF
+
+    tabs.expand_tabs(1).assert == expected
+
+Expanding tabs 4.
+
+    expected = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    |    One tab
+    |    One space and one tab
+    |         Six spaces, a tab, and a space
+    EOF
+
+    tabs.expand_tabs(4).assert == expected
+
+Expanding tabs 8.
+
+    expected = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    |        One tab
+    |        One space and one tab
+    |         Six spaces, a tab, and a space
+    EOF
+
+    tabs.expand_tabs.assert == expected
+    tabs.expand_tabs(8).assert == expected
+
+Expanding tabs 16.
+
+    expected = <<-EOF.gsub(/^\s+\|/, '')
+    |
+    |                One tab
+    |                One space and one tab
+    |                 Six spaces, a tab, and a space
+    EOF
+
+    tabs.expand_tabs(16).assert == expected
+

data/demo/core/string/fold.md

@@ -0,0 +1,14 @@
+## String#fold
+
+    require 'facets/string/fold'
+
+    s = "This is\na test.\n\nIt clumps\nlines of text."
+    o = "This is a test.\n\nIt clumps lines of text."
+    s.fold.assert == o
+
+leave spaces
+
+    s = "This is\na test.\n\n  This is pre.\n  Leave alone.\n\nIt clumps\nlines of text."
+    o = "This is a test.\n\n  This is pre.\n  Leave alone.\n\nIt clumps lines of text."
+    s.fold(true).assert == o
+

data/demo/core/string/indent.md

@@ -0,0 +1,65 @@
+## String#indent
+
+    require 'facets/string/indent'
+
+positive
+
+    "xyz".indent(4).assert == '    xyz'
+    "  xyz".indent(2).assert == '    xyz'
+
+multiline positive
+
+    "abc\nxyz".indent(2).assert ==  "  abc\n  xyz"
+
+zero
+
+    'xyz'.indent(0).assert == 'xyz'
+
+negative
+
+    '    xyz'.indent(-2).assert == '  xyz'
+    '  xyz'.  indent(-2).assert == 'xyz'
+
+multiline negative
+
+    "    abc\n    xyz".indent(-2).assert == "  abc\n  xyz"
+
+negative more than is possible
+
+    '  xyz'.indent(-3).assert == 'xyz'
+
+non-space positive
+
+    "xyz".indent(4, '-').assert == '----xyz'
+
+non-space zero
+
+    'xyz'.indent(0, '-').assert == 'xyz'
+
+non-space negative non-matching character
+
+    '    xyz'.indent(-2, '-').assert == '    xyz'
+    '  xyz'.  indent(-2, '-').assert == '  xyz'
+
+non-space negative
+
+    '----xyz'.indent(-2, '-').assert == '--xyz'
+    '--xyz'.indent(-2, '-').assert == 'xyz'
+
+Special regular expresion characters are escaped.
+
+Ensure '.' is treated literally and not as wildcard
+  
+    '  xyz'.indent(-2, '.').assert == '  xyz'
+    '..xyz'.indent(-2, '.').assert == 'xyz'
+
+Ensure '*' is treated literally and not as wildcard
+
+    '  xyz'.indent(-2, '*').assert == '  xyz'
+    '**xyz'.indent(-2, '*').assert == 'xyz'
+
+Ensure '^' is treated literally and not as line start
+
+    '  xyz'.indent(-2, '^').assert == '  xyz'
+    '^^xyz'.indent(-2, '^').assert == 'xyz'
+

data/demo/core/string/index_all.md

@@ -0,0 +1,14 @@
+## String#index_all
+
+    require 'facets/string/index_all'
+
+Returns an array of all index locations.  the reuse flag allows the trailing
+portion of a match to be resued for subsequent matches.
+
+    "abcabcabc".index_all('a')  #=> [0,3,6]
+
+    "a123a567a9".index_all(/a/)  #=> [0,4,8]
+
+    "bbb".index_all('bb', false)  #=> [0]
+    "bbb".index_all('bb', true)   #=> [0,1]
+

data/demo/core/string/interpolate.md

@@ -0,0 +1,8 @@
+## String#interpolate
+
+    require 'facets/string/interpolate'
+
+    a = 1
+
+    String.interpolate{ 'this is #{a}' }.assert == 'this is 1'
+

data/demo/core/string/lchomp.md

@@ -0,0 +1,14 @@
+## String#lchomp
+
+    require 'facets/string/lchomp'
+
+    s = "xxboo"
+    r = s.lchomp("xx")
+    r.assert == "boo"
+
+## String#lchomp!
+
+    s = "xxboo"
+    s.lchomp!("xx")
+    s.assert == "boo"
+