facets 2.9.2 → 2.9.3

data/qed/standard/02_cloneable.rdoc

@@ -0,0 +1,46 @@
+= 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/qed/standard/03_enumargs.rdoc

@@ -0,0 +1,75 @@
+= 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/qed/standard/04_equitable.rdoc

@@ -0,0 +1,35 @@
+= 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/qed/standard/05_instantiable.rdoc

@@ -0,0 +1,42 @@
+= 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/test/core/array/test_duplicates.rb

@@ -6,7 +6,21 @@ test_case Array do
 
     test do
       a = [1,1,2,2,3,4,5]
-      a.duplicates.assert == [1,2]
+      a.duplicates.sort.assert == [1,2]
+    end
+
+    test "with minimum" do
+      a = [0,1,2,3,4,5,
+           0,1,2,3,4,
+           0,1,2,3,
+           0,1,2,
+           0,1,
+           0]
+      (1..6).each do |m|
+        d = a.duplicates(m).sort
+        e = [*0..6-m]
+        d.assert == e
+      end
     end
 
   end

data/test/core/array/test_median.rb

@@ -0,0 +1,27 @@
+covers 'facets/array/median'
+
+test_case Array do
+
+  method :median do
+    test "odd sized" do
+      r = %w{e a b c d}.median
+      r.assert == "c"
+    end
+
+    test "even sized" do
+      r = %w{f e a b c d}.median
+      r.assert == "d"
+    end
+
+    test "with positive offset" do
+      r = %w{e a b c d}.median(1)
+      r.assert == "d"
+    end
+
+    test "with negative offset" do
+      r = %w{e a b c d}.median(-1)
+      r.assert == "b"
+    end
+  end
+
+end

data/test/core/array/test_nonuniq.rb

@@ -6,7 +6,7 @@ test_case Array do
 
     test do
       a = [1,1,2,2,3,4,5]
-      a.nonuniq.assert == [1,2]
+      a.nonuniq.sort.assert == [1,2]
     end
 
   end
@@ -16,7 +16,7 @@ test_case Array do
     test do
       a = [1,1,2,2,3,4,5]
       a.nonuniq!
-      a.assert == [1,2]
+      a.sort.assert == [1,2]
     end
 
   end

data/test/core/array/test_occurent.rb

@@ -0,0 +1,33 @@
+covers 'facets/array/occurent'
+
+test_case Array do
+
+  method :occurent do
+
+    test "set limit" do
+      a = [1,2,3,4,5,
+             2,3,4,5,
+               3,4,5,
+                 4,5,
+                   5]  
+      (1..5).each do |m|
+        d = a.occurent(m)
+        d.assert == [m]
+      end
+    end
+
+    test "range" do
+      a = %w{a b c d e
+               b c d e
+                 c d e
+                   d e
+                     e}
+      a.occurent(1..2).sort.assert == ['a','b']
+      a.occurent(1..3).sort.assert == ['a','b','c']
+      a.occurent(2..3).sort.assert == ['b','c']
+    end
+
+  end
+
+end
+

data/test/core/denumerable_tc.rb

@@ -1,5 +1,5 @@
 covers 'facets/denumerable'
-#require 'facets/enumerable/defer'
+covers 'facets/enumerable/defer'
 #require 'facets/enumerable/take'
 
 test_case Denumerable do
@@ -104,13 +104,12 @@ test_case Denumerator do
       d.assert == {1=>2,2=>4,3=>6,4=>8,5=>10}
     end
 
-    omit "can't use break in proc?" do
-      test do
-        d = (1..5).defer
-        d = d.inject({}){ |h,v| h[v] = v*2; break h if v>=3; h }
-        d.assert == {1=>2,2=>4,3=>6}
-      end
-    end
+    # TODO: problem with break in proc
+    #test do
+    #  d = (1..5).defer
+    #  d = d.inject({}){ |h,v| h[v] = v*2; break h if v>=3; h }
+    #  d.assert == {1=>2,2=>4,3=>6}
+    #end
   end
 
   method :max do

data/test/core/dir/test_each_child.rb

@@ -13,7 +13,7 @@ test_case Dir do
         c << path
       end
       d.close
-      c.sort.assert == ['core', 'core-uncommon', 'standard', 'supplemental']
+      c.sort.assert == ['core', 'standard']
     end
 
   end

data/test/core/dir/test_multiglob.rb

@@ -6,7 +6,7 @@ test_case Dir do
 
     test do
       r = Dir.multiglob('test/c*').sort
-      r.assert == ['test/core', 'test/core-uncommon']
+      r.assert == ['test/core']
     end
 
   end

data/test/core/enumerable/test_sum.rb

@@ -8,6 +8,28 @@ test_case Enumerable do
       [1,2,3].sum.assert == 6
     end
 
+    test 'with block' do
+      a = [1.0, 2.1, 3.2].sum(&:to_i)
+      a.assert == 6
+    end
+
+    test 'with identity' do
+      a = [].sum(9)
+      a.assert == 9
+
+      a = [1].sum(9)
+      a.assert == 1
+    end
+
+    test 'with identity and block' do
+      # notice identity is not effected by block (correct?)
+      a = [].sum(9.1, &:to_i)
+      a.assert == 9.1
+
+      a = [1.1].sum(9.1, &:to_i)
+      a.assert == 1
+    end
+
   end
 
 end

data/test/core/hash/test_url_params.rb

@@ -0,0 +1,26 @@
+covers 'facets/hash/url_params'
+
+testcase Hash do
+
+  method :url_params do
+
+    test 'simple hash' do
+      hash1 = {:foo => "bar"}
+      hash1.url_params.assert == "foo=bar"
+    end
+
+    test 'hash with array value' do
+      hash2 = {"foo" => ["bar", "fab", 1]}
+      hash2.url_params.assert == "foo=bar,fab,1"
+    end
+
+    test 'hash with multiple elements' do
+      hash3 = {:foo => [:bar, :asdf,1], :fee => 1}
+      params = hash3.url_params
+      params.assert.include? "foo=bar,asdf,1"
+      params.assert.include? "fee=1"
+    end
+
+  end
+
+end

data/test/core/kernel/test_constant.rb

@@ -5,11 +5,11 @@ test_case Kernel do
   method :constant do
 
     test do
-      c = Lemon::TestCase.name
-      constant(c).assert == Lemon::TestCase
+      c = ::Lemon::TestCase.name
+      constant(c).assert == ::Lemon::TestCase
 
       c = "TestCase"
-      Lemon.constant(c).assert == Lemon::TestCase
+      ::Lemon.constant(c).assert == ::Lemon::TestCase
     end
 
   end

data/test/core/kernel/test_hierarchical_send.rb

@@ -0,0 +1,48 @@
+require 'facets/kernel/hierarchical_send'
+
+test_case Object do
+
+  setup do
+    m = Module.new do
+      attr :a
+      def preinitialize
+        @a = 10
+      end
+    end
+
+    @x = Class.new do
+      include m
+      attr :b
+      def preinitialize
+        @b = 20
+      end
+      def initialize
+        hierarchical_send(:preinitialize)
+      end
+    end
+
+    @y = Class.new(@x) do
+      def initialize
+        @a = "not 10"
+        @b = "not 20"
+        super
+      end
+    end
+  end
+
+  method :hierarchical_send do
+    test do
+      x = @x.new
+      x.a.assert == 10
+      x.b.assert == 20
+    end
+
+    test 'subclass' do
+      y = @y.new
+      y.a.assert == 10
+      y.b.assert == 20
+    end
+  end
+
+end
+