facets 3.0.0 → 3.1.0

data/demo/core/string/unquote.rdoc

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

data/demo/core/string/variablize.rdoc

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

data/demo/core/string/word_wrap.rdoc

@@ -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.rdoc

@@ -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.rdoc

@@ -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/lib/core/facets/binding/local_variables.rb

@@ -1,16 +0,0 @@
-class Binding
-
-  # Returns the local variables defined in the binding context:
-  #
-  #   a = 1
-  #   b = 2
-  #
-  #   binding.local_variables  #=> [:a, :b]
-  #
-  # TODO: Rename this to prevent name clash?
-  def local_variables()
-    eval("local_variables")
-  end
-
-end
-

data/lib/core/facets/string/tab.rb

@@ -1,2 +0,0 @@
-# DEPRECATED
-require 'facets/string/indent'

data/lib/core/facets/string/tabto.rb

@@ -1,2 +0,0 @@
-# DEPRECATED
-require 'facets/string/margin'

data/test/core/array/test_after.rb

@@ -1,27 +0,0 @@
-covers 'facets/array/after'
-
-testcase Array do
-
-  method :after do
-
-    setup do
-      @sequence = ['a', 'b', 'c']
-    end
-
-    test "returns the following element" do
-      @sequence.after('a').assert == 'b'
-      @sequence.after('b').assert == 'c'
-    end
-
-    test "loops around from back to front" do
-      @sequence.after('c').assert == 'a'
-    end
-
-    test "non-member elements return nil" do
-      @sequence.after('d').assert == nil
-    end
-
-  end
-
-end
-

data/test/core/array/test_combination.rb

@@ -1,25 +0,0 @@
-covers 'facets/array/combination'
-
-test_case Array do
-
-  method :combination do
-
-    test "finds pairs of combinations" do
-      e = [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
-      a = [1,2,3,4]
-      r = a.combination(2).to_a
-      r.assert == e
-    end
-
-    test "can also take a block" do
-      e = [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
-      r = []
-      a = [1,2,3,4]
-      a.combination(2){ |a,b| r << [a,b] }
-      r.assert == e
-    end
-
-  end
-
-end
-

data/test/core/array/test_index.rb

@@ -1,20 +0,0 @@
-covers 'facets/array/index'
-
-test_case Array do
-
-  method :index do
-
-    test "can handle a block" do
-      i = [1,2,3].index{ |e| e == 2 }
-      i.assert == 1
-    end
-
-    test "when no element is found" do
-      i = [1,2,3].index{ |e| e == 5 }
-      i.assert.nil?
-    end
-
-  end
-
-end
-

data/test/core/array/test_permutation.rb

@@ -1,20 +0,0 @@
-covers 'facets/array/permutation'
-
-test_case Array do
-
-  method :permutation do
-
-    test do
-      r = []
-      %w[a b c].permutation{ |x| r << x.join('') }
-
-      x = ['abc','acb','bac','bca','cab','cba']
-      x.each do |e|
-        r.assert.include?(e)
-      end
-    end
-
-  end
-
-end
-

data/test/core/array/test_product.rb

@@ -1,64 +0,0 @@
-covers 'facets/array/product'
-
-test_case Array do
-
-  method :product do
-
-    test "single argument" do
-      r = [1,2,3].product([4,5,6])
-      x = [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]]
-      r.assert == x
-    end
-
-    test "multiple arguments" do
-      a = %w|a b|
-      b = %w|a x|
-      c = %w|x y|
-      r = a.product(b, c)
-      x = [ ["a", "a", "x"],
-            ["a", "a", "y"],
-            ["a", "x", "x"],
-            ["a", "x", "y"],
-            ["b", "a", "x"],
-            ["b", "a", "y"],
-            ["b", "x", "x"],
-            ["b", "x", "y"] ]
-      r.assert == x
-    end
-
-  end
-
-  #def test_product_01
-  #  i = [[1,2], [4], ["apple", "banana"]]
-  #  o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
-  #  assert_equal( o, Enumerable.product(*i) )
-  #end
-
-  #     def test_op_mod
-  #       a = [:A,:B,:C]
-  #       assert_equal( a[1], a/1 )
-  #       assert_equal( :B, a/1 )
-  #     end
-  #
-  #     def test_op_div
-  #       a = [:A,:B,:C]
-  #       assert_equal( a[1], a/1 )
-  #       assert_equal( :B, a/1 )
-  #     end
-
-
-  #def test_op_mod
-  #  a = [:A,:B,:C]
-  #  assert_equal( a[1], a/1 )
-  #  assert_equal( :B, a/1 )
-  #end
-  #
-  #def test_op_div
-  #  a = [:A,:B,:C]
-  #  assert_equal( a[1], a/1 )
-  #  assert_equal( :B, a/1 )
-  #end
-
-end
-
-

data/test/core/array/test_rotate.rb

@@ -1,38 +0,0 @@
-covers 'facets/array/rotate'
-
-test_case Array do
-
-  method :rotate do
-
-    test "clockwise" do
-      a = [1,2,3]
-      r = a.rotate
-      r.assert == [2,3,1]
-    end
-
-    test "counter-clockwise" do
-      a = [1,2,3]
-      r = a.rotate(-1)
-      r.assert == [3,1,2]
-    end
-
-  end
-
-  method :rotate! do
-
-    test "clockwise" do
-      a = [1,2,3]
-      a.rotate!
-      a.assert == [2,3,1]
-    end
-
-    test "counter-clockwise" do
-      a = [1,2,3]
-      a.rotate!(-1)
-      a.assert == [3,1,2]
-    end
-
-  end
-
-end
-

data/test/core/array/test_select.rb

@@ -1,16 +0,0 @@
-covers 'facets/array/select'
-
-test_case Array do
-
-  method :select! do
-
-    test do
-      a = [1,2,3,4,5,6,7,8,9,10]
-      a.select!{ |e| e % 2 == 0 }
-      a.assert == [2,4,6,8,10]
-    end
-
-  end
-
-end
-

data/test/core/binding/test_eval.rb

@@ -1,15 +0,0 @@
-covers 'facets/binding/eval'
-
-test_case Binding do
-
-  x = "hello"
-  bind = binding
-
-  method :eval do
-    test do
-      bind.eval("x").assert == "hello"
-    end
-  end
-
-end
-

data/test/core/binding/test_local_variables.rb

@@ -1,36 +0,0 @@
-covers 'facets/binding/local_variables'
-
-test_case Binding do
-
-  a = 1
-  b = 2
-  x = "hello"
-
-  bind = binding
-
-  unless RUBY_VERSION > "1.9"
-
-    method :local_variables do
-      test do
-        bind.local_variables.assert.include? "bind"
-        bind.local_variables.assert.include? "x"
-        bind.local_variables.assert.include? "a"
-        bind.local_variables.assert.include? "b"
-      end
-    end
-
-  else
-
-    method :local_variables do
-      test do
-        bind.local_variables.assert.include? :bind
-        bind.local_variables.assert.include? :x
-        bind.local_variables.assert.include? :a
-        bind.local_variables.assert.include? :b
-      end
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_cluster_by.rb

@@ -1,30 +0,0 @@
-covers 'facets/enumerable/cluster_by'
-
-test_case Enumerable do
-
-  method :cluster_by do
-
-    test "on an array" do
-      a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-      e = [[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]
-      r = a.cluster_by{|x| x % 2} #.each{|a| a.sort!}
-      r.assert == e
-    end
-
-    test "on a hash" do
-      h = {0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9}
-      e = [[[0, 0], [2, 2], [4, 4], [6, 6], [8, 8]], [[1, 1], [3, 3], [5, 5], [7, 7], [9, 9]]]
-      r = h.cluster_by{|k, v| v % 2}.each{|a| a.sort!}
-      r.assert == e
-    end
-
-    test "on an empty array" do
-      r = [].cluster_by{ |a| a }
-      r.assert == []
-    end
-
-  end
-
-end
-
-

data/test/core/enumerable/test_count.rb

@@ -1,32 +0,0 @@
-covers 'facets/enumerable/count'
-
-test_case Enumerable do
-
-  method :count do
-
-    test "strings" do
-      e = ['a','1','a']
-      r = e.count('1')
-      r.assert == 1
-
-      e = ['a','1','a']
-      r = e.count('a')
-      r.assert == 2
-    end
-
-    test "array of arrays" do
-      e = [['a',2],['a',2],['a',2],['b',1]]
-      r = e.count(['a',2])
-      r.assert == 3
-    end
-
-    test "hash" do
-      e = { :a=>2, 'b'=>1, :c=>2 }
-      r = e.count(2)
-      r.assert == 2
-    end
-
-  end
-
-end
-