facets 3.1.0 → 3.2.0

data/demo/core/string/underscore.md

@@ -1,17 +0,0 @@
-## String#underscore
-
-    require 'facets/string/underscore'
-
-Underscore a string such that camelcase, dashes and spaces are
-replaced by underscores. This is the reverse of {#camelcase},
-albeit not an exact inverse.
-
-Note, this method no longer converts `::` to `/`, in that case
-use the {#pathize} method instead.
-
-    'my_name'.underscore.assert == 'my_name'
-
-    'MyName'.underscore.assert == 'my_name'
-
-    'URI'.underscore.assert == 'uri'
-

data/demo/core/string/unfold.md

@@ -1,9 +0,0 @@
-## String#unfold
-
-    require 'facets/string/unfold'
-
-    str = "This is a test of\nparagraph folding."
-    res = str.unfold
-    exp = "This is a test of paragraph folding."
-    res.assert == exp
-

data/demo/core/string/unindent.md

@@ -1,65 +0,0 @@
-## String#unindent
-
-    require 'facets/string/unindent'
-
-We will use these two strings as a common basis for demonstration.
-
-    ex1 = <<-EOF.gsub(/^\s*\|/,'')
-    |    I must go down to the seas again
-    |      The lonely sea and the sky
-    |    And all I want is a tall ship
-    |      And a star to steer her by
-    EOF
-
-    ex2 = <<-EOF.gsub(/^\s*\|/,'')
-    |     "Eek!"
-    |  She cried
-    |    As the mouse quietly scurried
-    |by.
-    EOF
-
-simple examples
-
-    "   xyz".unindent(-1).assert == "    xyz"
-    "   xyz".unindent(0).assert  == "   xyz"
-    "   xyz".unindent(1).assert  == "  xyz"
-    "   xyz".unindent(2).assert  == " xyz"
-    "   xyz".unindent(3).assert  == "xyz"
-    "   xyz".unindent(4).assert  == "xyz"
-
-large example unindented one space
-
-    expected = <<-EOF.gsub(/^\s*\|/,'')
-    |   I must go down to the seas again
-    |     The lonely sea and the sky
-    |   And all I want is a tall ship
-    |     And a star to steer her by
-    EOF
-
-    actual = ex1.unindent(1)
-    actual.assert == expected
-
-large example unindented four spaces
-
-    expected = <<-EOF.gsub(/^\s*\|/,'')
-    |I must go down to the seas again
-    |  The lonely sea and the sky
-    |And all I want is a tall ship
-    |  And a star to steer her by
-    EOF
-
-    actual = ex1.unindent(4)
-    actual.assert == expected
-
-unindent larger than current indention
-
-    expected = <<-EOF.gsub(/^\s*\|/,'')
-    |"Eek!"
-    |She cried
-    |As the mouse quietly scurried
-    |by.
-    EOF
-
-    actual = ex2.unindent(100)
-    actual.assert == expected
-

data/demo/core/string/unquote.md

@@ -1,6 +0,0 @@
-## String#unquote
-
-    require 'facets/string/unquote'
-
-    "'this'".unquote.assert == "this"
-

data/demo/core/string/uppercase.md

@@ -1,15 +0,0 @@
-## String#uppercase
-
-    require 'facets/string/uppercase'
-
-Upcase the first letter.
-
-    s = 'bob'
-    s.uppercase.assert == 'Bob'
-
-    s = 'boB'
-    s.uppercase.assert == 'BoB'
-
-    s = 'BoB'
-    s.uppercase.assert == 'BoB'
-

data/demo/core/string/variablize.md

@@ -1,7 +0,0 @@
-## String#variablize
-
-    require 'facets/string/variablize'
-
-    s = "a"
-    s.variablize.assert == "@a"
-

data/demo/core/string/word_wrap.md

@@ -1,54 +0,0 @@
-## String#word_wrap
-
-    require 'facets/string/word_wrap'
-
-    e = "abcde\n12345\nxyzwu\n"
-    r = "abcde 12345 xyzwu".word_wrap(5)
-    r.assert == e
-
-    e = "abcd\n1234\nxyzw\n"
-    r = "abcd 1234 xyzw".word_wrap(4)
-    r.assert == e
-
-    e = "abc\n123\n"
-    r = "abc 123".word_wrap(4)
-    r.assert == e
-
-    e = "abc \n123\n"
-    r = "abc  123".word_wrap(4)
-    r.assert == e
-
-    e = "abc \n123\n"
-    r = "abc     123".word_wrap(4)
-    r.assert == e
-
-## String#word_wrap!
-
-    w = "abcde 12345 xyzwu"
-    w.word_wrap!(5)
-    w.assert == "abcde\n12345\nxyzwu\n"
-
-    w = "abcd 1234 xyzw"
-    w.word_wrap!(4)
-    w.assert == "abcd\n1234\nxyzw\n"
-
-    w = "abc 123"
-    w.word_wrap!(4)
-    w.assert == "abc\n123\n"
-
-    w = "abc  123"
-    w.word_wrap!(4)
-    w.assert == "abc \n123\n"
-
-    w = "abc     123"
-    w.word_wrap!(4)
-    w.assert == "abc \n123\n"
-
-    # Unit :word_wrap do
-    #   assert_equal "abcde-\n12345-\nxyzwu\n", "abcde12345xyzwu".word_wrap(6,2)
-    #   assert_equal "abcd-\n1234-\nxyzw\n", "abcd1234xyzw".word_wrap(5,2)
-    #   assert_equal "abc \n123\n", "abc 123".word_wrap(4,2)
-    #   assert_equal "abc \n123\n", "abc  123".word_wrap(4,2)
-    #   assert_equal "abc \n123\n", "abc     123".word_wrap(4,2)
-    # end
-

data/demo/core/string/words.md

@@ -1,13 +0,0 @@
-## String#words
-
-    require 'facets/string/words'
-
-    x = "a b c\nd e"
-    x.words.assert == ['a','b','c','d','e']
-
-    x = "ab cd\nef"
-    x.words.assert == ['ab','cd','ef']
-
-    x = "ab cd \n ef-gh"
-    x.words.assert == ['ab','cd','ef-gh']
-

data/demo/core/string/xor.md

@@ -1,8 +0,0 @@
-## String#^
-
-    require 'facets/string/xor'
-
-    r = "try this out" ^ "puddingsnacks"
-    x = "\004\a\035D\035\006\016\000N\016\026\037"
-    r.assert == x
-

data/demo/standard/02_cloneable.rdoc

@@ -1,46 +0,0 @@
-= Cloneable
-
-Require the library.
-
-  require 'facets/cloneable'
-
-We'll use this dummy class.
-
-  class Foo
-    include Cloneable
-    def initialize
-      @bar=[]
-    end
-    def bar_id
-      @bar.object_id
-    end
-  end
-
-Try #dup.
-
-  a = Foo.new
-  b = a.dup
-  b.bar_id.refute == a.bar_id
-
-  a.taint
-  b = a.dup
-  b.assert.tainted?
-
-  a.freeze
-  b = a.dup
-  b.refute.frozen?
-
-Note try #clone.
-
-  a = Foo.new
-  b = a.clone
-  b.bar_id.refute == a.bar_id
-
-  a.taint
-  b = a.dup
-  b.assert.tainted?
-
-  a.freeze
-  b = a.clone
-  b.assert.frozen?
-

data/demo/standard/03_enumargs.rdoc

@@ -1,75 +0,0 @@
-= Enumerable::Arguments
-
-Require the library.
-
-  require 'facets/enumargs'
-
-This will serve as our example class.
-
-  class PlusArray
-    include Enumerable::Arguments
-
-    def initialize(arr)
-      @arr = arr
-    end
-
-    def each(n=0)
-      @arr.each{ |e| yield(e+n) }
-    end
-  end
-
-Now Enumerable methods such as #map and #collect
-take an argument as well.
-
-  t = PlusArray.new([1,2,3])
-  t.collect(4){ |e| e }.assert == [5,6,7]
-
-Filtering methods such as #select and reject work
-as well.
-
-  t = PlusArray.new([1,2,3])
-  t.select(4){ |x| x == 6 }.assert == [6]
-
-  t = PlusArray.new([1,2,3])
-  t.reject(4){ |x| x == 6 }.assert == [5,7]
-
-We can covert to an array using #to_a with an argument.
-
-  t = PlusArray.new([1,2,3])
-  t.to_a(4).assert == [5,6,7]
-
-We can get the minimum value using #min.
-
-  t = PlusArray.new([1,2,3])
-  t.min(4).assert == 5
-
-And get the maximum value using #min.
-
-  t = PlusArray.new([1,2,3])
-  t.max(4).assert == 7
-
-Methods that already take and argument, now take two
-such as #include?
-
-  t = PlusArray.new([1,2,3])
-  t.assert.include?(7,4)
-
-And #each_slice.
-
-  t = PlusArray.new([1,2,3,4])
-  a = []
-  t.each_slice(2,4){ |e,f| a << [e,f] }
-  a.assert == [[5,6],[7,8]]
-
-The #find method has a slightly different interface
-than the original Enumerable.
-
-  t = PlusArray.new([1,2,3,4])
-  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
-  f.assert == :NOPE
-
-The #grep method should also work.
-
-  t = PlusArray.new(['a1','b2','a3','b4'])
-  t.grep(/^b/, 'x').assert == ['b2x','b4x']
-

data/demo/standard/04_equitable.rdoc

@@ -1,35 +0,0 @@
-= Equitqable
-
-Require the library.
-
-  require 'facets/equitable'
-
-We will use this simple class as an example.
-
-  class C
-    include Equitable(:a,:b)
-
-    attr_accessor :a, :b
-
-    def initialize(a,b)
-      @a = a
-      @b = b
-    end
-  end
-
-Now, if two instance of our sample class +C+ have
-equal attributes +@a+ and +@b+ then they will
-be equal.
-
-  c1 = C.new(10,20)
-  c2 = C.new(10,20)
-  c2.assert == c1
-
-Otherwise they will not be equal.
-
-  c1 = C.new(10, 10)
-  c2 = C.new(10, 20)
-  c2.refute == c1
-
-
-

data/demo/standard/05_instantiable.rdoc

@@ -1,42 +0,0 @@
-= Instantiable
-
-Require the library.
-
-  require 'facets/instantiable'
-
-We will use this module as an example.
-
-  module M
-    include Instantiable
-
-    attr :a
-
-    def initialize(a)
-      @a = a
-    end
-  end
-
-As we can see M is now fully instantiable, as any
-class would be.
-
-    m = M.new(1)
-    m.a.assert == 1
-
-We can also use #extend rather than #include and
-get the same result.
-
-  module N
-    extend Instantiable
-
-    attr :a
-
-    def initialize( a )
-      @a = a
-    end
-  end
-
-As we saw with +M+ so too with +N+.
-
-  n = N.new( 1 )
-  n.a.assert == 1
-

data/demo/standard/basic_object.rdoc

@@ -1,22 +0,0 @@
-== BasicObject
-
-  require 'facets/basicobject'
-
-  o = Class.new(BasicObject).new
-
-Should ignore new kernel methods.
-
-  Kernel.module_eval { def xxx ; end }
-
-  expect NoMethodError do
-    o.xxx
-  end
-
-Should ignore new object methods.
-
-  Object.class_eval { def yyy ; end }
-
-  expect NoMethodError do
-    o.yyy
-  end
-

data/demo/standard/memoizable.rdoc

@@ -1,134 +0,0 @@
-= Memoizable
-
-Memoizable allows
-
-  require 'facets/memoizable'
-
-The classic example is calculating the Fibonacci sequence.
-
-  class Fibonacci
-    include Memoizable
-
-    def fib( num )
-      return num if num < 2
-      fib(num - 1) + fib(num - 2)
-    end
-
-    memoize :fib
-  end
-
-The first time will take a moment to calculate.
-
-  f = Fibonacci.new
-  f.fib(100)
-
-The second time will be returned almost instantly.
-
-  f = Fibonacci.new
-  f.fib(100)
-
-The following example makes if very clear what memoize is doing.
-
-  class MemoExample
-    include Memoizable
-    attr_accessor :a
-    memoize :a
-  end
-
-  m = MemoExample.new
-  m.a = 10
-  m.a         #=> 10
-  m.a = 20
-  m.a         #=> 10
-
-Even though @a is assigned to 20, the method #a continues to return 10.
-
-Memoizable is designed to handle a number of typically problematic aspects
-of memoization implementations. First a memoizable object can be frozen.
-
-  f = Fibonacci.new
-  f.freeze
-  f.fib(100)
-
-Memoizable objects are freezable because it does not use an instance variable
-to store the memoized return values. Instead it uses a global class instance
-variable in +Memoizable.cache+.
-
-However, this also means the memoization cache is not preserved when an object
-is duplicated. If this behavior is desired an aditional module is provided
-called `Memoizable::Copy`. When the `Memoiazble::Copy` module is included into
-a class it not only adds the #memoize class methods but also includes
-an #initialize_copy method, which copies the appropriate cache entries when
-#dup or #clone is used. Keep this in mind. It is important to call #super if you
-override the #initialize_copy method in a class that uses `Memoizable::Copy`.
-
-  class MemoExample2
-    include Memoizable::Copy
-    attr_accessor :a
-    memoize :a
-  end
-
-  m = MemoExample2.new
-  m.a = 10
-  m.a         #=> 10
-
-  n = m.dup
-  n.a = 20
-  n.a         #=> 10
-
-The `#memoize` method also accepts a few options that can be used to modify
-the behvior of the memoizaiton. To memoize a method across all objects
-of the same class and not just per-object, set the `:class` option to true.
-
-  class MemoExample3
-    include Memoizable
-    attr_accessor :a
-    memoize :a, :class=>true
-  end
-
-  m = MemoExample3.new
-  m.a = 10
-  m.a         #=> 10
-
-  n = MemoExample3.new
-  n.a         #=> 10
-
-Memoization is indexed based on arguments passed to the method, as can be seen 
-in the Fibonacci example. Methods can also be memoized by name only, forgoing
-any indexing based on arguments passed. To do this, set the `:arguments`
-option to +false+.
-
-  class MemoExample4
-    include Memoizable
-    def f(n)
-      n + n
-    end
-    memoize :f, :arguments=>false
-  end
-
-  m = MemoExample4.new
-  m.f(1)
-  m.f(2)      #=> 2
-  m.f(3)      #=> 2
-
-Blocks passed to a method normally have only a present vs. non-present effect
-on the memoization index. In other words the return value of a method will be
-cached under one key if a block is passed to it and under a different index
-if not. It doesn't matter if blocks passed in actually differ, since
-the only way to compare blocks is by their +object_id+ and it is very rare
-for the exact same block object to be reused.
-
-Finally, the `:freeze` option can be used to freeze the memoized results.
-
-  class MemoExample5
-    include Memoizable
-    def f(n)
-      (n + n).to_s
-    end
-    memoize :f, :freeze=>true
-  end
-
-  m = MemoExample5.new
-  m.f(1).frozen?      #=> true
-  m.f(2).frozen?      #=> true
-