facets 3.0.0 → 3.1.0

data/demo/core/class/to_proc.rdoc

@@ -1,8 +0,0 @@
-== Class#to_proc
-
-  require 'facets/class/to_proc'
-
-  person = Struct.new(:name)
-  people = ["joe"].map(&person)
-  people[0].name.assert == "joe"
-

data/demo/core/comparable/cap.rdoc

@@ -1,20 +0,0 @@
-== Comparable#cap
-
-  require 'facets/comparable/cap'
-
-  3.cap(4).assert == 3
-  4.cap(4).assert == 4
-  5.cap(4).assert == 4
-
-== Comparable#at_most
-
-  3.at_most(4).assert == 3
-  4.at_most(4).assert == 4
-  5.at_most(4).assert == 4
-
-== Comparable#at_least
-
-  3.at_least(4).assert == 4
-  4.at_least(4).assert == 4
-  5.at_least(4).assert == 5
-

data/demo/core/comparable/clip.rdoc

@@ -1,37 +0,0 @@
-== Comparable#clip
-
-  require 'facets/comparable/clip'
-
-single argument
-
-  3.clip(4).assert == 4
-  4.clip(4).assert == 4
-  5.clip(4).assert == 5
-
-two arguments
-
-  4.clip(3,5).assert == 4
-  3.clip(3,5).assert == 3
-  5.clip(3,5).assert == 5
-  2.clip(3,5).assert == 3
-  6.clip(3,5).assert == 5
-
-on strings
-
-  'd'.clip('c','e').assert == 'd'
-  'c'.clip('c','e').assert == 'c'
-  'e'.clip('c','e').assert == 'e'
-  'b'.clip('c','e').assert == 'c'
-  'f'.clip('c','e').assert == 'e'
-
-== Comparable#bound
-
-The bound method is an alias for #clip. It is actually
-the original name of this method.
-
-  3.bound(4).assert == 4
-
-  4.bound(3,5).assert == 4
-
-  'd'.bound('c','e').assert == 'd'
-

data/demo/core/comparable/cmp.rdoc

@@ -1,18 +0,0 @@
-== Comparable#cmp
-
-  require 'facets/comparable/cmp'
-
-on integers
-
-  3.cmp(4).assert == -1
-  3.cmp(3).assert ==  0
-  3.cmp(2).assert ==  1
-
-on strings
-
-  "abc".cmp("abc").assert == 0
-  "abc".cmp("abcd").assert == -1
-  "abcd".cmp("abc").assert ==  1
-  "abc".cmp("bcd").assert == -1
-  "bcd".cmp("abc").assert ==  1
-

data/demo/core/comparable/op_get.rdoc

@@ -1,29 +0,0 @@
-== Comparable#[]
-
-  require 'facets/comparable/op_get'
-
-  c = Class.new do
-    include Comparable[:a,:b]
-
-    attr_accessor :a, :b
-
-    def initialize(a,b)
-      @a=a; @b=b
-    end
-  end
-
-  a = [c.new(10,20),c.new(10,30)]
-  a.sort.assert == a
-
-  a = [c.new(10,30),c.new(10,20)]
-  a.sort.assert == a.reverse
-
-  a = [c.new(10,10),c.new(20,10)]
-  a.sort.assert == a
-
-  a = [c.new(20,10),c.new(10,10)]
-  a.sort.assert == a.reverse
-
-  a = [c.new(10,30),c.new(20,10)]
-  a.sort.assert == a
-

data/demo/core/dir/ascend.rdoc

@@ -1,24 +0,0 @@
-== Dir#ascend
-
-  require 'facets/dir/ascend'
-
-  path = 'A/B/C'
-
-  tmp = []
-
-  Dir.ascend(path) do |d|
-    tmp << d
-  end
-
-  tmp.assert == %w{A/B/C A/B A}
-
-Exclude current path.
-
-  tmp = []
-
-  Dir.ascend(path, false) do |d|
-    tmp << d
-  end
-  
-  tmp.assert == %w{A/B A}
-

data/demo/core/dir/descend.rdoc

@@ -1,14 +0,0 @@
-== Dir#descend
-
-  require 'facets/dir/descend'
-
-  path = 'A/B/C'
-
-  tmp = []
-
-  Dir.descend(path) do |d|
-    tmp << d
-  end
-
-  tmp.assert == %w{A A/B A/B/C}
-

data/demo/core/dir/multiglob.rdoc

@@ -1,41 +0,0 @@
-== Dir#multiglob
-
-Dir#multglob is like Dir#glob but it can handle more than one match
-parameter at a time.
-
-Given a directory 'multiglob' containing:
-
-  A.txt
-  A/B.txt
-  A/B/C.txt
-
-We can use #multglob to find multiple matches.
-
-  require 'facets/dir/multiglob'
-
-  x = %w{
-    multiglob/A
-    multiglob/A.txt
-  }
-
-  r = Dir.multiglob('multiglob/A', 'multiglob/A.*').sort
-
-  r.assert == x
-
-== Dir#multiglob_r
-
-Dir#multiglob_r is like #multiglob but automatically searches
-directories recrusively.
-
-  x = %w{
-    multiglob/A 
-    multiglob/A/B
-    multiglob/A.txt
-    multiglob/A/B.txt
-    multiglob/A/B/C.txt
-  }.sort
-
-  r = Dir.multiglob_r('multiglob/*').sort
-
-  r.assert == x
-

data/demo/core/dir/parent.rdoc

@@ -1,6 +0,0 @@
-== Dir#parent
-
-  require 'facets/dir/parent'
-
-  Dir.assert.parent?("a/b/c", "a/b/c/d")
-

data/demo/core/dir/recurse.rdoc

@@ -1,41 +0,0 @@
-== Dir#recurse
-
-Given a directory 'recurse' containing:
-
-  A.txt
-  A/B.txt
-  A/B/C.txt
-
-We can use #recurse to gather a complete recursive
-list of all the entries.
-
-  require 'facets/dir/recurse'
-
-  x = %w{
-    recurse/A
-    recurse/A.txt
-    recurse/A/B
-    recurse/A/B.txt
-    recurse/A/B/C.txt
-  }.sort
-
-  r = Dir.recurse('recurse').sort
-
-  r.assert == x
-
-== Dir#ls_r
-
-Dir#ls_r is an alias for #recurse which can also be used to gather
-a complete recursive list of all the entries.
-
-  x = %w{
-    recurse/A
-    recurse/A.txt
-    recurse/A/B
-    recurse/A/B.txt
-    recurse/A/B/C.txt
-  }.sort
-
-  r = Dir.ls_r('recurse').sort
-
-  r.assert == x

data/demo/core/exception/detail.rdoc

@@ -1,12 +0,0 @@
-== Exception#detail
-
-  require 'facets/exception/detail'
-
-  begin
-    raise ArgumentError
-  rescue ArgumentError => err
-    e = 
-    r = err.detail
-    r.assert == e
-  end
-

data/demo/core/filetest/root.rdoc

@@ -1,6 +0,0 @@
-== FileTest#root?
-
-  require 'facets/filetest/root'
-
-  FileTest.assert.root?('/')
-

data/demo/core/hash/recursively.rdoc

@@ -1,21 +0,0 @@
-== Hash#recursively
-
-  require 'facets/hash/recursively'
-
-  h = {:a=>1, :b=>{:c=>3}}
-
-Without a block passed tot he #recursive method, the block passed to the
-enumeratig method will be used for both recursive and non-recursive yields.
-
-  r = h.recursively.map{ |k,v| [k.to_s, v] }
-
-  r.assert == [['a', 1], ['b', [['c', 3]]]]
-
-But if we pass a block to #recursive we can treat the recusive yield 
-separately, which in turn allows us to manipulate the non-recursive
-yields with a different procedure.
-
-  r = h.recursively{ |k,v| [k.to_s, v] }.map{ |k,v| [k.to_s,v.to_s] }
-
-  r.assert == [['a','1'], ['b', [['c', '3']]]]
-

data/demo/core/indexable.rdoc

@@ -1,95 +0,0 @@
-= Indexable
-
-Indexable it a module, like Enumerable, but provides methods specific
-to an indexable collection. The Indexable module can be used independently,
-but Facets can also automatically use it to extend Array.
-
-  require 'facets/array/indexable'
-
-== Indexable#head
-
-  a = [1,2,3,4,5]
-  a.head.assert = [1]
-
-== Indexable#tail
-
-  a = [1,2,3,4,5]
-  a.tail.assert = [2,3,4,5]
-
-== Indexable#foot
-
-  a = [1,2,3,4,5]
-  a.foot.assert = [5]
-
-== Indexable#body
-
-  a = [1,2,3,4,5]
-  a.body.assert = [1,2,3,4]
-
-== Indexable#mid
-
-    a = [1,2,3,4,5]
-    b = [1,2,3,4,5,6]
-    a.mid.assert = 3
-    b.mid.assert = 4
-    a.mid(1).assert = 4
-    b.mid(1).assert = 5
-    b.mid(2).assert = 6
-    b.mid(-1).assert = 3
-
-== Indexable#middle
-
-  a = [1,2,3,4,5]
-  b = [1,2,3,4,5,6]
-  a.middle.assert = [3]
-  b.middle.assert = [3,4]
-
-== Indexable#thru
-
-  [0,1,2,3,4,5].thru(2,4).assert = [2,3,4]
-  [0,1,2,3,4,5].thru(0,1).assert = [0,1]
-
-== Indexable#first=
-
-  a = [1,2]
-  a.first = 0
-  a.assert = [0,2]
-
-== Indexable#last=
-
-  a = [1,2]
-  a.last = 3
-  a.assert = [1,3]
-
-== Indexable#ends
-
-  [1,2,3,4,5].ends.assert = 4
-
-== Indexable#pos
-
-  a = [1,2,3,4,5]
-  a.pos(1).assert = 0
-  a.pos(-1).assert = 4
-
-== Indexable#range
-
-  a = [1,2,3,4,5]
-  b = [1,2,3,4,5,6]
-  a.range.assert = (0..4)
-  b.range.assert = (0..5)
-  a.range(2,4).assert = (1..3)
-  b.range(2,3).assert = (1..2)
-  b.range(4,2).assert = (3..1)
-
-== Indexable#first!
-
-  a = [1,2,3]
-  a.first!.assert = 1
-  a.assert = [2,3]
-
-== Indexable#last!
-
-  a = [1,2,3]
-  a.last!.assert = 3
-  a.assert = [1,2]
-

data/demo/core/integer/bitmask.rdoc

@@ -1,46 +0,0 @@
-== 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/demo/core/integer/even.rdoc

@@ -1,12 +0,0 @@
-== 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
-