facets 2.8.4 → 2.9.0.pre.1

data/qed/core/string/rewrite.rdoc

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

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

@@ -0,0 +1,9 @@
+== String#snakecase
+
+  require 'facets/string/snakecase'
+
+  '/my_module/my_class/'.snakecase.assert == '/my_module/my_class/'
+  'MyModule::MyClass'.snakecase.assert == 'my_module/my_class'
+  '::MyClass'.snakecase.assert == '/my_class'
+  'URI'.snakecase.assert == 'uri'
+

data/qed/core/string/splice.rdoc

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

@@ -0,0 +1,7 @@
+== String#start_with?
+
+  require 'facets/string/start_with'
+
+  s = "xxboo"
+  s.assert.start_with?('xx')
+

data/qed/core/string/subtract.rdoc

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

data/qed/core/string/tab.rdoc

@@ -0,0 +1,16 @@
+== String#tab
+
+  require 'facets/string/tab'
+
+  a = "abc".tab(2)
+  a.assert == "  abc"
+
+If we add a new line we see that both are tabbed.
+
+  a = "abc\nxyz".tab(2)
+  a.assert == "  abc\n  xyz"
+
+Unlike #tabto, #tab indents all lines equally regardless of prior indention.
+
+  a = "abc\n  xyz".tab(2)
+  a.assert == "  abc\n  xyz"

data/qed/core/string/tabto.rdoc

@@ -0,0 +1,29 @@
+== String#tabto
+
+  require 'facets/string/tabto'
+
+String#tabto indeent lines relative to their current indentions. Using #tabto
+on a single line behaves just like #tab.
+
+  a = "xyz".tabto(2)
+  a.assert ==  "  xyz"
+
+  a = "    xyz".tabto(2)
+  a.assert ==  "  xyz"
+
+If the string has multiple lines, then each line will be indented
+accordingly.
+
+  a = "abc\nxyz".tabto(2)
+  a.assert ==  "  abc\n  xyz"
+
+Unlike #tab, the left margin of indention is determined by the first
+non-blank line.
+
+  a = "  abc\n    xyz".tabto(2)
+  a.assert ==  "  abc\n    xyz"
+
+If we add a blank line at the begining it will be the same.
+
+  a = " \n  abc\n    xyz".tabto(2)
+  a.assert ==  " \n  abc\n    xyz"

data/qed/core/string/titlecase.rdoc

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

data/qed/core/string/to_re.rdoc

@@ -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/
+

data/qed/core/string/unfold.rdoc

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

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

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

data/qed/core/string/variablize.rdoc

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

data/qed/core/string/word_wrap.rdoc

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

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

@@ -0,0 +1,8 @@
+== 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/qed/more/basic_object.rdoc

@@ -0,0 +1,22 @@
+== 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/qed/more/memoizable.rdoc

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