facets 2.8.4 → 2.9.0.pre.1

data/qed/core/integer/bitmask.rdoc

@@ -0,0 +1,46 @@
+== Integer#bit
+
+  require 'facets/integer/bitmask'
+
+  0.bit(0).assert == 1
+  0.bit(1).assert == 2
+  0.bit(2).assert == 4
+  0.bit(3).assert == 8
+
+negate
+
+  1.bit(~0).assert == 0
+  2.bit(~1).assert == 0
+  4.bit(~2).assert == 0
+  8.bit(~3).assert == 0
+
+== Integer#bit?
+
+  a = 8
+  assert(! a.bit?(0))
+  assert(! a.bit?(1))
+  assert(! a.bit?(2))
+  assert(  a.bit?(3))
+  assert(! a.bit?(4))
+  assert(! a.bit?(5))
+
+== Integer#bit_clear
+
+  1.bit_clear(0).assert == 0
+  2.bit_clear(1).assert == 0
+  4.bit_clear(2).assert == 0
+  8.bit_clear(3).assert == 0
+
+== Integer#bitmask
+
+  a =  1
+  m = Bit(4)
+  a = a.bitmask(m)
+  a.assert == 17
+  assert( a.bitmask?(m) )
+
+== Kernel#Bit
+
+  n = Bit(4)
+  n.assert == 16
+

data/qed/core/integer/even.rdoc

@@ -0,0 +1,12 @@
+== Integer#even?
+
+    require 'facets/integer/even'
+
+    (-100..100).step(2) do |n|
+      n.even?.assert == true
+    end
+
+    (-101..101).step(2) do |n|
+      n.even?.assert == false
+    end
+

data/qed/core/integer/factorial.rdoc

@@ -0,0 +1,10 @@
+== Integer#factorial
+
+    require 'facets/integer/factorial'
+
+    0.factorial.assert == 1
+    1.factorial.assert == 1
+    2.factorial.assert == 2
+    3.factorial.assert == 6
+    4.factorial.assert == 24
+

data/qed/core/integer/length.rdoc

@@ -0,0 +1,7 @@
+== Numeric#length
+
+    require 'facets/numeric/length'
+
+    10.length.assert == 10
+    10.0.length.assert == 10
+

data/qed/core/integer/multiple.rdoc

@@ -0,0 +1,10 @@
+== Integer#multiple?
+
+    require 'facets/integer/multiple'
+
+    1.multiple?(2)  #=> false
+    5.multiple?(3)  #=> false
+
+    2.multiple?(2)  #=> true
+    6.multiple?(3)  #=> true
+

data/qed/core/integer/odd.rdoc

@@ -0,0 +1,12 @@
+== Integer#odd?
+
+    require 'facets/integer/odd'
+
+    (-101..101).step(2) do |n|
+      n.odd?.assert == true
+    end
+
+    (-100..100).step(2) do |n|
+      n.odd?.assert == false
+    end
+

data/qed/core/integer/of.rdoc

@@ -0,0 +1,14 @@
+== Integer#of
+
+    require 'facets/integer/of'
+
+    a = 4
+    b = a.of{ |i| i*2 }
+    b.assert == [0,2,4,6]
+
+== Integer#times_collect
+
+    a = 4
+    b = a.times_collect{ |i| i*2 }
+    b.assert == [0,2,4,6]
+

data/qed/core/integer/ordinal.rdoc

@@ -0,0 +1,9 @@
+= Integer#ordinal
+
+    require 'facets/integer/ordinal'
+
+    1.ordinal.assert == '1st'
+    2.ordinal.assert == '2nd'
+    3.ordinal.assert == '3rd'
+    4.ordinal.assert == '4th'
+

data/qed/core/matchdata/match.rdoc

@@ -0,0 +1,7 @@
+= MatchData#match
+
+  require 'facets/matchdata/match'
+
+  md = /X(a)(b)(c)X/.match("YXabcXY")
+  md.match.assert == "XabcX"
+

data/qed/core/matchdata/matchset.rdoc

@@ -0,0 +1,15 @@
+== MatchData#matchtree
+
+  require 'facets/matchdata/matchset'
+
+  md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+  md.matchtree.assert == [["bb"], ["cc", ["dd"]], ["ee"]]
+
+  md = /(bb)c(c(dd))(ee)/.match "XXaabbccddeeffXX"
+  md.matchtree.assert == [["bb"], "c", ["c", ["dd"]], ["ee"]]
+
+== MatchData#matchset
+
+  md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+  md.matchset.assert == ["XXaa", [["bb"], ["cc", ["dd"]], ["ee"]], "ffXX"]
+

data/qed/core/string/align.rdoc

@@ -0,0 +1,34 @@
+== String#align
+
+  require 'facets/string/align'
+
+Align a string to a given position. This method simply delegates
+to the other three more specific align methods.
+
+  "xxx".align(:right, 9).assert == "      xxx"
+  "xxx".align(:left,  9).assert == "xxx      "
+
+== String#align_right
+
+Align a string to the right. The default alignment separation is
+a newline ("\n"). This can be changed as can be the padding string
+which defaults to a single space (' ').
+
+  "xxx".align_right(9).assert == "      xxx"
+
+== String#align_left
+
+Align a string to the left. The default alignment separation is a
+newline ("\n"). This can be changed as can be the padding string
+which defaults to a single space (' ').
+
+  "xxx".align_left(9).assert == "xxx      "
+
+== String#align_center
+
+Centers each line of a string. The default alignment separation is
+a new line ("\n"). This can be changed as can be the padding string
+which defaults to a single space (' ').
+
+  "xxx".align_center(9).assert == "   xxx   "
+

data/qed/core/string/bracket.rdoc

@@ -0,0 +1,35 @@
+== String#bracket
+
+  require 'facets/string/bracket'
+
+  'X'.bracket('#').assert == '#X#'
+  'X'.bracket('x','!').assert == 'xX!'
+  'X'.bracket('{','}').assert == '{X}'
+  'X'.bracket('<').assert == '<X>'
+  'X'.bracket('(').assert == '(X)'
+  'X'.bracket('[').assert == '[X]'
+  'X'.bracket('{').assert == '{X}'
+
+== String#bracket!
+
+    a = 'X' ; a.bracket!('#')
+    a.assert == '#X#'
+
+    a = 'X' ; a.bracket!('x','!')
+    a.assert == 'xX!'
+
+    a = 'X' ; a.bracket!('{','}')
+    a.assert == '{X}'
+
+    a = 'X' ; a.bracket!('<')
+    a.assert == '<X>'
+
+    a = 'X' ; a.bracket!('(')
+    a.assert == '(X)'
+
+    a = 'X' ; a.bracket!('[')
+    a.assert == '[X]'
+
+    a = 'X' ; a.bracket!('{')
+    a.assert == '{X}'
+

data/qed/core/string/bytes.rdoc

@@ -0,0 +1,8 @@
+== String#bytes
+
+  require 'facets/string/bytes'
+
+  s = "abc"
+
+  s.bytes.to_a.assert == s.unpack('C*')
+

data/qed/core/string/camelcase.rdoc

@@ -0,0 +1,67 @@
+== 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 capitalized.
+
+  "Camel_case".camelcase.assert == "CamelCase"
+
+Passing +true+ to #camelcase uncaptializes the first letter. This is
+known as lower-camelcase.
+
+  "Abc_xyz".camelcase(true).assert == "abcXyz"
+  "Abc____xyz".camelcase(true).assert == "abcXyz"
+
+Where as passing +false+ leaves the first as it was given, known as
+inter-camelcase.
+
+  "abc_xyz".camelcase(false).assert == "abcXyz"
+  "abc____xyz".camelcase(false).assert == "abcXyz"
+  "Abc_xyz".camelcase(false).assert == "AbcXyz"
+  "Abc____xyz".camelcase(false).assert == "AbcXyz"
+
+The #camelcase method applies to each word in a string.
+
+  #Unit :camelcase => "converts spaces to captialized" do
+  #  "abc xyz".camelcase.assert  == "AbcXyz"
+  #  "abc  xyz".camelcase.assert == "AbcXyz"
+  #  "abc\txyz".camelcase.assert == "AbcXyz"
+  #  "abc\nxyz".camelcase.assert == "AbcXyz"
+  #end
+
+  #Unit :camelcase => "false converts spaces to captialized" do
+  #  "abc xyz".camelcase(false).assert == "abcXyz"
+  #  "abc  xyz".camelcase(false).assert == "abcXyz"
+  #  "abc\txyz".camelcase(false).assert == "abcXyz"
+  #  "abc\nxyz".camelcase(false).assert == "abcXyz"
+  #end
+
+In addition #camelcase converts path separators ('/') to module name
+separators ('::').
+
+  'this_is_it'.camelcase.assert == 'ThisIsIt'
+  'my_module/my_class'.camelcase.assert == 'MyModule::MyClass'
+  '/my_module/my_class'.camelcase.assert == '::MyModule::MyClass'
+
+  #Unit :camelcase => "converts methods to module names" do
+  #  'my_module__my_class'.camelcase.assert == 'MyModule::MyClass'
+  #  '__my_module__my_class'.camelcase.assert == '::MyModule::MyClass'
+  #end
+
+== String#lower_camelcase
+
+  "abc_xyz".lower_camelcase.assert == "abcXyz"
+
+== String#upper_camelcase
+
+  "abc_xyz".upper_camelcase.assert == "AbcXyz"
+

data/qed/core/string/capitalized.rdoc

@@ -0,0 +1,27 @@
+== String#capitalized?
+
+String#capitalized? return true if a string begins with a capitalized
+letter, false otherwise.
+
+  require 'facets/string/capitalized'
+
+  'Abc'.assert.capitalized?
+
+== 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.lowercase?
+
+== String#upcase?
+
+And String#upcase? which checks to see if the whole string is composed
+of uppercase letters.
+
+  'ABC'.assert.upcase?
+
+  #'ABC'.assert.uppercase?
+

data/qed/core/string/characters.rdoc

@@ -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/qed/core/string/cleanlines.rdoc

@@ -0,0 +1,10 @@
+== 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'
+
+  "a \n b \nc".cleanlines.to_a.assert == ["a","b","c"]
+

data/qed/core/string/cleave.rdoc

@@ -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/qed/core/string/divide.rdoc

@@ -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/qed/core/string/each_char.rdoc

@@ -0,0 +1,9 @@
+== String#each_char
+
+  require 'facets/string/each_char'
+
+  a = []
+  i = "this"
+  i.each_char{ |w| a << w }
+  a.assert == ['t', 'h', 'i', 's']
+

data/qed/core/string/each_word.rdoc

@@ -0,0 +1,9 @@
+== 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/qed/core/string/end_with.rdoc

@@ -0,0 +1,6 @@
+= String#end_with?
+
+  require 'facets/string/end_with'
+
+  "xxboo".assert.end_with?('boo')
+