facets 3.0.0 → 3.1.0

data/demo/core/string/line_wrap.md

@@ -0,0 +1,7 @@
+## String#line_wrap
+
+    require 'facets/string/line_wrap'
+
+    "abc123".line_wrap(3).assert == "abc\n123\n"
+    "abcd123".line_wrap(4).assert == "abcd\n123\n"
+

data/demo/core/string/lowercase.md

@@ -0,0 +1,12 @@
+## String#lowercase
+
+    require 'facets/string/lowercase'
+
+Downcase the first letter.
+
+    s = 'Abc'
+    s.lowercase.assert == 'abc'
+
+    s = 'ABC'
+    s.lowercase.assert == 'aBC'
+

data/demo/core/string/methodize.md

@@ -0,0 +1,22 @@
+## String#methodize
+
+    require 'facets/string/methodize'
+
+module name
+
+    a = "FooBase"
+    r = "foo_base"
+    a.methodize.assert == r
+
+path name
+
+    a = "foo/base"
+    r = "foo__base"
+    a.methodize.assert == r
+
+name space
+
+    a = "Foo::Base"
+    r = "foo__base"
+    a.methodize.assert == r
+

data/demo/core/string/modulize.md

@@ -0,0 +1,22 @@
+## String#modulize
+
+    require 'facets/string/modulize'
+
+snakecase
+
+    a = "foo_bar"
+    r = "FooBar"
+    a.modulize.assert == r
+
+path name
+
+    a = "foo/bar"
+    r = "Foo::Bar"
+    a.modulize.assert == r
+
+on methodized string
+
+    a = "foo__bar"
+    r = "Foo::Bar"
+    a.modulize.assert == r
+

data/demo/core/string/mscan.md

@@ -0,0 +1,10 @@
+## String#mscan
+
+    require 'facets/string/mscan'
+
+    r = 'abc,def,gh'.mscan(/[,]/)
+    assert( r.all?{ |md| MatchData === md } )
+    r.to_a.length.assert == 2
+    r[0][0].assert == ','
+    r[1][0].assert == ','
+

data/demo/core/string/natcmp.md

@@ -0,0 +1,10 @@
+## String#natcmp
+
+    require 'facets/string/natcmp'
+
+    "my_prog_v1.1.0".natcmp( "my_prog_v1.2.0").assert == -1
+    "my_prog_v1.2.0".natcmp("my_prog_v1.10.0").assert == -1
+    "my_prog_v1.2.0".natcmp( "my_prog_v1.1.0").assert == 1
+    "my_prog_v1.10.0".natcmp("my_prog_v1.2.0").assert == 1
+    "my_prog_v1.0.0".natcmp( "my_prog_v1.0.0").assert == 0
+

data/demo/core/string/nchar.md

@@ -0,0 +1,9 @@
+## String#nchar
+
+    require 'facets/string/nchar'
+
+    "abcxyz".nchar(3).assert == "abc"
+    "abcxyz".nchar(-3).assert == "xyz"
+    "abcxyz".nchar(3, 'HI').assert == "HIxyz"
+    "abcxyz".nchar(-3, 'HI').assert == "abcHI"
+

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

@@ -1,9 +1,9 @@
-== String#newlines
+## String#newlines
 
 Since Ruby 1.9 defined #lines to keep the newline character,
 we have defined #newlines to leave them out.
 
-  require 'facets/string/newlines'
+    require 'facets/string/newlines'
 
-  "a\nb\nc".newlines.to_a.assert == ["a","b","c"]
+    "a\nb\nc".newlines.to_a.assert == ["a","b","c"]
 

data/demo/core/string/number.md

@@ -0,0 +1,27 @@
+## String#number?
+
+    require 'facets/string/number'
+
+Returns true if its a decimal number
+
+    x = "1.23\n"
+    x.number?.assert == true
+
+    x = "123_456_789_123_456_789.123_456_000_111\n"
+    x.number?.assert == true
+
+    x = ".123\n"
+    x.number?.assert == false
+
+    x = "123_\n"
+    x.number?.assert == false
+
+    x = "_123\n"
+    x.number?.assert == false
+
+    x = "23_456_789_123_456_.245\n"
+    x.number?.assert == false
+
+    x = "23_456_789_123_456._245\n"
+    x.number?.assert == false
+

data/demo/core/string/op_div.md

@@ -0,0 +1,10 @@
+## String#op_div
+
+    require 'facets/string/op_div'
+
+Treats +self+ and +path+ as representations of pathnames, joining thme together
+as a single path.
+
+    ('merb' / 'string').assert == "merb/string"
+    ('merb' / :symbol).assert == "merb/symbol"
+

data/demo/core/string/op_sub.md

@@ -0,0 +1,7 @@
+## String#-
+
+    require 'facets/string/op_sub'
+
+    s = "xxbooxxfoo"
+    (s - "xx").assert == "boofoo"
+

data/demo/core/string/pathize.md

@@ -0,0 +1,22 @@
+## String#pathize
+
+    require 'facets/string/pathize'
+
+module name
+
+    a = "Foo::Base"
+    x = "foo/base"
+    a.pathize.assert == x
+
+path name
+
+    a = "foo/base"
+    x = "foo/base"
+    a.pathize.assert == x
+
+name space
+
+    a = "foo__base"
+    x = "foo/base"
+    a.pathize.assert == x
+

data/demo/core/string/quote.md

@@ -0,0 +1,20 @@
+## String#quote
+
+    require 'facets/string/quote'
+
+The default is single quotes.
+
+    'hi'.quote.assert == %{"hi"}
+
+The type of quotes can be specified by name.
+
+    'hi'.quote(:single).assert == %{'hi'}
+    'hi'.quote(:double).assert == %{"hi"}
+    'hi'.quote(:back).assert == %{`hi`}
+
+They can also be specified by the first character of the name.
+
+    'hi'.quote(:s).assert == %{'hi'}
+    'hi'.quote(:d).assert == %{"hi"}
+    'hi'.quote(:b).assert == %{`hi`}
+

data/demo/core/string/random.md

@@ -0,0 +1,25 @@
+## String#random
+
+    require 'facets/string/random'
+
+Generates a random string of given length, using given character set
+
+    s = String.random
+    # "D9DxFIaqR3dr8Ct1AfmFxHxqGsmA4Oz3"
+    s.assert =~ /^[0-9a-zA-Z]{32}$/
+
+    s = String.random(10)
+    # "t8BIna341S"
+    s.assert =~ /^[0-9a-zA-Z]{10}$/
+
+    s = String.random(10, ['a'..'z'])
+    # "nstpvixfri"
+    s.assert =~ /^[a-z]{10}$/
+
+    s = String.random(10, ['0'..'9'] )
+    # "0982541042"
+    s.assert =~ /^[0-9]{10}$/
+
+    s = String.random(10, ['0'..'9','A'..'F'] )
+    # "3EBF48AD3D"
+    s.assert =~ /^[0-9A-F]{10}$/

data/demo/core/string/range.md

@@ -0,0 +1,19 @@
+## String#range
+
+    require 'facets/string/range'
+
+    "a123a567a9".range(/123/).assert == (1..3)
+    "a123a567a9".range(/a/).assert == (0..0)
+
+## String#range_all
+
+    "a123a123a9".range_all(/123/).assert == [ (1..3), (5..7) ]
+    "a123a567a9".range_all(/a/).assert == [ (0..0), (4..4), (8..8) ]
+
+## String#range_of_line
+
+    a = "0123\n456\n78"
+    x = [0..4, 5..8, 9..10]
+    r = a.range_of_line
+    r.assert == x
+

data/demo/core/string/remove.md

@@ -0,0 +1,33 @@
+## String#remove
+
+    require 'facets/string/remove'
+
+Removes all occurances of a string or pattern from a string.
+
+    s = 'xxbooxxfoo'
+    s.remove('xx').assert == 'boofoo'
+
+    s = 'xxbooxxfoo'
+    s.remove(/x{1,2}/).assert == 'boofoo'
+
+## String#remove!
+
+    s = 'xxbooxxfoo'
+    s.remove!('xx')
+    s.assert == 'boofoo'
+
+    s = 'xxbooxxfoo'
+    s.remove!(/x{1,2}/)
+    s.assert == 'boofoo'
+
+
+## String#op_minus (-)
+
+    s = 'xxbooxxfoo'
+    (s - 'xx').assert == 'boofoo'
+
+    s = 'xxbooxxfoo'
+    (s - /x{1,2}/).assert == 'boofoo'
+
+
+

data/demo/core/string/rewrite.md

@@ -0,0 +1,9 @@
+## String#rewrite
+
+    require 'facets/string/rewrite'
+
+    s = "HELLO TOMMY!"
+    rules = [[ /TOMMY/, 'MAN' ]]
+    r = s.rewrite(rules)
+    r.assert == "HELLO MAN!"
+

data/demo/core/string/shatter.md

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

data/demo/core/string/similarity.md

@@ -0,0 +1,12 @@
+## String#similarity
+
+    require 'facets/string/similarity'
+
+A fuzzy matching mechanism. Returns a score from 0-1, based on the number of
+shared edges. To be effective, the strings must be of length 2 or greater.
+
+    "Alexsander".similarity("Aleksander").assert == 0.9
+
+    "Alexander".similarity("Alexander").assert == 1.0
+
+    "Alexander".similarity("").assert == 0.0

data/demo/core/string/snakecase.md

@@ -0,0 +1,14 @@
+## String#snakecase
+
+    require 'facets/string/snakecase'
+
+Underscore a string such that camelcase, dashes and spaces are
+replaced by underscores. This is the reverse of {#camelcase},
+albeit not an exact inverse.
+
+    'my_name'.snakecase.assert == 'my_name'
+
+    'MyName'.snakecase.assert == 'my_name'
+
+    'URI'.snakecase.assert == 'uri'
+

data/demo/core/string/splice.md

@@ -0,0 +1,28 @@
+## String#splice
+
+    require 'facets/string/splice'
+
+    a = "HELLO"
+    a.splice(1).assert == "E"
+    a.assert == "HLLO"
+
+range
+
+    a = "HELLO"
+    a.splice(1..2).assert == "EL"
+    a.assert == "HLO"
+
+store
+
+    a = "HELLO"
+    a.splice(1, "X")
+    a.assert == "HXLLO"
+
+This could be done if class of 2nd arg is checked.
+
+    #Unit :splice_length
+    #  a = "HELLO"
+    #  a.splice(1,2).assert == "EL"
+    #  a.assert == "HLO"
+    #end
+

data/demo/core/string/squish.md

@@ -0,0 +1,27 @@
+## String#squish
+
+    require 'facets/string/squish'
+
+Returns the string, first removing all whitespace on both ends of the string,
+and then changing remaining consecutive whitespace groups into one space each.
+
+    r = %{ Multi-line
+           string }.squish
+    r.assert == "Multi-line string"
+
+    r = " foo   bar    \n   \t   boo".squish
+    r.assert == "foo bar boo"
+
+## String#squish!
+
+Performs a destructive squish. See String#squish.
+
+    r = %{ Multi-line
+           string }
+    r.squish!
+    r.assert == "Multi-line string"
+
+    r = " foo   bar    \n   \t   boo"
+    r.squish!
+    r.assert == "foo bar boo"
+

data/demo/core/string/store.md

@@ -0,0 +1,10 @@
+## String#store
+
+    require 'facets/string/store'
+
+Alias for []=
+
+    a = "HELLO"
+    a.store(1, "X")
+    a.assert == "HXLLO"
+

data/demo/core/string/subtract.md

@@ -0,0 +1,8 @@
+## String#-
+
+    require 'facets/string/subtract'
+
+    ("foobar" - "oo").assert == "fbar"
+    ("pizza pizza!" - "zz").assert == "pia pia!"
+    ("letters" - /[a-z]+/).assert == ""
+

data/demo/core/string/titlecase.md

@@ -0,0 +1,8 @@
+## String#titlecase
+
+    require 'facets/string/titlecase'
+
+    r = "try this out".titlecase
+    x = "Try This Out"
+    r.assert == x
+

data/demo/core/string/to_re.md

@@ -0,0 +1,22 @@
+## String#to_re
+
+    require 'facets/string/to_re'
+
+    "abc".to_re.assert == /abc/
+    "a+bc".to_re.assert == /a+bc/
+    "a+bc".to_re(false).assert == /a+bc/
+    "a+bc".to_re(true).assert == /a\+bc/
+
+escaped characters
+
+    a = "?"
+    b = /#{a.to_rx}/
+    assert( b =~ "?" )
+
+## String#to_rx
+
+    "abc".to_rx.assert == /abc/
+    "a+bc".to_rx.assert == /a\+bc/
+    "a+bc".to_rx(false).assert == /a+bc/
+    "a+bc".to_rx(true).assert == /a\+bc/
+