facets 3.0.0 → 3.2.0

data/demo/core/module/class_extend.rdoc

@@ -1,64 +0,0 @@
-== Module#class_extend
-
-  require 'facets/module/class_extend'
-
-Module using class_extend
-
-  mix = Module.new do
-    def i ; end
-    class_extend do
-      def n ; 42   ; end
-      def s ; self ; end
-    end
-  end
-
-Extends module
-
-  mix.n.assert == 42
-  mix.s.assert == mix
-
-Has expected methods
-
-  mix.instance_methods.map{ |m| m.to_s }.assert == ['i']
-
-transfers class methods to including class
-
-  mod = Module.new do
-    include mix
-  end
-  mod.n.assert == 42
-  mod.s.assert == mod
-
-Doesn't overwrite instance methods
-
-  c = Class.new do
-    include mix
-    def n ; 11 ; end
-  end
-  c.new.n.assert == 11
-
-Is overridable via including module
-
-  mod = Module.new do
-    include mix
-    class_extend do
-      def n ; super + 1 ; end
-    end
-  end
-  mod.n.assert == 43  # notice the difference!
-  mod.s.assert == mod
-
-Transfers class methods thru multiple levels of include
-
-  alt = Module.new do
-    include mix
-    class_extend do
-      def n ; super + 1 ; end
-    end
-  end
-  mod = Module.new do
-    include alt
-  end
-  mod.n.assert == 43
-  mod.s.assert == mod
-

data/demo/core/module/class_inheritor.rdoc

@@ -1,126 +0,0 @@
-== Module#class_inheritor
-
-  require 'facets/module/class_inheritor'
-
-Subclass with inheritor
-
-    c = Class.new do
-      class_inheritor :koko, [], :+
-      koko! << 1
-    end
-
-    d = Class.new(c) do
-      class_inheritor :koko, [], :+
-      koko! << 2
-    end
-
-We can see that
-
-    c.koko!.assert == [1]
-    c.koko.assert  == [1]
-
-    d.koko!.assert == [2]
-    d.koko.assert  == [1,2]
-
-Subclass without class_inheritor
-
-    c = Class.new do
-      class_inheritor :koko, [], :+
-      koko! << 1
-    end
-
-    d = Class.new(c)
-
-Likewise
-
-    c.koko!.assert == [1]
-    c.koko.assert  == [1]
-
-    d.koko!.assert == []
-    d.koko.assert  == [1]
-
-
-Include module with class_inheritor
-
-    c = Class.new do
-      class_inheritor :x, {}, :merge
-      x![:a] = 1
-    end
-
-    m = Module.new do
-      class_inheritor :x, {}, :merge
-      x![:b] = 2
-    end
-
-    d = Class.new(c) do
-      include m
-      class_inheritor :x, {}, :merge
-      x![:c] = 3
-    end
-
-Then
-
-    c.x.assert == {:a=>1}
-
-    m.x[:b].assert == 2
-
-    d.x.assert == {:a=>1,:b=>2,:c=>3}
-
-    c.x[:a].assert == 1
-    c.x[:b].assert == nil
-    c.x[:c].assert == nil
-
-    d.x[:a].assert == 1
-    d.x[:b].assert == 2
-    d.x[:c].assert == 3
-
-And
-
-    d.x![:d] = 4
-    d.x[:d].assert == 4
-
-
-Using #concat as the class_inheritor operator
-
-    c = Class.new do
-      class_inheritor :relations, [], :concat
-    end
-
-    d = Class.new(c) do
-      #class_inheritor :relations, [], :concat
-    end
-
-    c.relations! << 1
-    c.relations! << 2
-    d.relations! << 3
-
-Notice
-
-    c.relations.assert == [1,2]
-    d.relations.assert == [1,2,3]
-
-
-On Module
-
-    m = Module.new do
-      class_inheritor :koko, [], :+
-      koko! << 1
-    end
-
-    c1 = Class.new do
-      include m
-      #class_inheritor :koko, [], :+
-      koko! << 2
-      koko! << 3
-    end
-
-    c2 = Class.new do
-      include m
-      #class_inheritor :koko, [], :+
-      koko! << 4
-    end
-
-    m.koko.assert  == [1]
-    c1.koko.assert == [1,2,3]
-    c2.koko.assert == [1,4]
-

data/demo/core/module/copy_inheritor.rdoc

@@ -1,30 +0,0 @@
-= Module#copy_inheritor
-
-  require 'facets/module/copy_inheritor'
-
-We see copy_inheritor
-
-    m = Module.new do
-      copy_inheritor :koko, []
-      koko << 1
-    end
-
-    c1 = Class.new do
-      include m
-      #inheritor :koko, [], :+
-      koko << 2
-      koko << 3
-    end
-
-    c2 = Class.new do
-      include m
-      #inheritor :koko, [], :+
-      koko << 4
-    end
-
-copy_inheritor
-
-    m.koko.assert  == [1]
-    c1.koko.assert == [1,2,3]
-    c2.koko.assert == [1,4]
-

data/demo/core/module/method_space.rdoc

@@ -1,55 +0,0 @@
-== Module#method_space
-
-  require 'facets/module/method_space'
-
-  class A
-    attr_writer :x
-    method_space :inside do
-      def x; @x; end
-    end
-  end
-
-  a = A.new
-  a.x = 10
-
-We can see that the `inside` method space has access to the instance space.
-
-  a.inside.x  #=> 10
-
-But there is no reader in the instance space.
-
-  expect NoMethodError do
-    a.x
-  end
-
-== Module#include_as
-
-  require 'facets/module/include_as'
-
-Module#include_as utilizes #method_space to allow modules to be included
-within a separated namespace.
-
-  module T
-    def t ; "Tt"  ; end
-    def r ; "Tr"  ; end
-    def q ; super ; end
-  end
-
-  class N
-    def q ; "Nq" ; end
-  end
-
-  class X < N
-    include_as :test => T
-
-    def n ; test.inspect ; end
-    def m ; test.t ; end
-    def o ; test.r ; end
-  end
-
-  x = X.new
-
-  x.m.assert == "Tt"
-  x.o.assert == "Tr"
-  x.q.assert == "Nq"
-

data/demo/core/string/align.rdoc

@@ -1,34 +0,0 @@
-== 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/demo/core/string/bracket.rdoc

@@ -1,35 +0,0 @@
-== 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/demo/core/string/bytes.rdoc

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

data/demo/core/string/camelcase.rdoc

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

@@ -1,27 +0,0 @@
-== 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/demo/core/string/characters.rdoc

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

@@ -1,10 +0,0 @@
-== 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/demo/core/string/cleave.rdoc

@@ -1,49 +0,0 @@
-== 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/divide.rdoc

@@ -1,9 +0,0 @@
-== 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_char.rdoc

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

data/demo/core/string/each_word.rdoc

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

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

data/demo/core/string/expand_tabs.rdoc

@@ -1,69 +0,0 @@
-== 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.rdoc

@@ -1,14 +0,0 @@
-== 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.rdoc

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