facets-glimmer 3.2.0

data/test/core/hash/test_to_proc.rb

@@ -0,0 +1,23 @@
+covers 'facets/hash/to_proc'
+
+test_case Hash do
+
+  method :to_proc do
+
+    test do
+      c = Class.new do
+        attr_accessor :a
+      end
+
+      h = {:a => 1}
+      o = c.new
+
+      h.to_proc.call(o)
+
+      o.a.assert == 1
+    end
+
+  end
+  
+end
+

data/test/core/hash/test_to_struct.rb

@@ -0,0 +1,22 @@
+covers 'facets/hash/to_struct'
+
+test_case Hash do
+
+  method :to_struct do
+
+    test do
+      h = {:name=>"Dan","age"=>33,"rank"=>"SrA","grade"=>"E4"}
+      s = h.to_struct("Foo")
+
+      s.name.assert  = "Dan"
+      s.age.assert   = 33
+      s.rank.assert  = "SrA"
+      s.grade.assert = "E4"
+
+      #Foo.assert.is_a?(Struct) ?
+    end
+
+  end
+  
+end
+

data/test/core/hash/test_traverse.rb

@@ -0,0 +1,29 @@
+covers 'facets/hash/traverse'
+
+test_case Hash do
+
+  method :traverse do
+
+    test do
+      h = { "A" => "x", "B" => "y" }
+      j = h.traverse{ |k,v| [k.downcase, v.upcase] }
+      x = { "a" => "X", "b" => "Y" }
+      j.refute == h
+      j.assert == x
+    end
+
+  end
+
+  method :traverse! do
+
+    test do
+      h = { "A" => "x", "B" => "y" }
+      h.traverse!{ |k,v| [k.downcase, v.upcase] }
+      x = { "a" => "X", "b" => "Y" }
+      h.assert == x
+    end
+
+  end
+
+end
+

data/test/core/hash/test_update_each.rb

@@ -0,0 +1,16 @@
+covers 'facets/hash/update_each'
+
+test_case Hash do
+
+  method :update_each do
+
+    test do
+      a = { :a => 1, :b => 2, :c => 3 }
+      x = { :a => 2, :b => 3, :c => 4 }
+      a.update_each{ |k,v| { k => v+1 } }
+      a.assert == x
+    end
+
+  end
+
+end

data/test/core/hash/test_update_keys.rb

@@ -0,0 +1,21 @@
+covers 'facets/hash/update_keys'
+
+test_case Hash do
+
+  method :update_keys do
+
+    test do
+      h = { 'A' => 1, 'B' => 2 }
+      h.update_keys{ |k| k.downcase }
+      h.assert == {'a' => 1, 'b' => 2}
+    end
+
+    test do
+      h = { :a => 1, :b => 2 }
+      h.update_keys{ |k| "#{k}!" }
+      h.assert == {'a!' => 1, 'b!' => 2}
+    end
+
+  end
+
+end

data/test/core/hash/test_update_values.rb

@@ -0,0 +1,15 @@
+covers 'facets/hash/update_values'
+
+test_case Hash do
+
+  method :update_values do
+
+    test do
+      h = {1 => 'A', 2 => 'B'}
+      h.update_values{ |v| v.downcase }
+      h.assert == {1 => 'a', 2 => 'b'}
+    end
+
+  end
+
+end

data/test/core/hash/test_weave.rb

@@ -0,0 +1,18 @@
+covers 'facets/hash/weave'
+
+test_case Hash do
+
+  method :weave do
+
+    test do
+      b = { :a=>1, :b=>[1,2,3], :c=>{ :x=>'X' } }
+      c = { :a=>2, :b=>[4,5,6], :c=>{ :x=>'A', :y => 'B' } }
+      x = { :a=>2, :b=>[1,2,3,4,5,6], :c=>{ :x => 'A', :y => 'B' } }
+      b.weave(c).assert == x
+    end
+
+  end
+
+end
+
+

data/test/core/hash/test_zip.rb

@@ -0,0 +1,16 @@
+covers 'facets/hash/zip'
+
+test_case Hash do
+
+  class_method :zip do
+
+    test do
+      a = [1,2,3]
+      b = [4,5,6]
+      Hash.zip(a,b).assert == {1=>4,2=>5,3=>6}
+    end
+
+  end
+
+end
+

data/test/core/indexable_tc.rb

@@ -0,0 +1,232 @@
+covers 'facets/indexable'
+covers 'facets/array/indexable'
+
+test_case Indexable do
+
+  method :head do
+    test do
+      [1,2,3].head.assert == [1]
+    end
+  end
+
+  method :tail do
+    test do
+      [1,2,3].tail.assert == [2,3]
+    end
+  end
+
+  method :foot do
+    test do
+      [1,2,3].foot.assert == [3]
+    end
+  end
+
+  method :body do
+    test do
+      [1,2,3].body.assert == [1,2]
+    end
+  end
+
+  method :mid do
+    test do
+      %w{W o r l d}.mid.assert == 'r'
+      %w{W o r l d}.mid(1).assert == 'l'
+      %w{W o r l d}.mid(-1).assert == 'o'
+    end
+  end
+
+  method :mid do
+    test do
+      a = [1,2,3,4,5]
+      b = [1,2,3,4,5,6]
+      a.mid.assert == 3
+      b.mid.assert == 4
+      a.mid(1).assert == 4
+      b.mid(1).assert == 5
+      b.mid(2).assert == 6
+      b.mid(-1).assert == 3
+    end
+  end
+
+  method :middle do
+    test do
+      [1,2,3,4,5].middle.assert == [3]
+      [1,2,3,4,5,6].middle.assert == [3,4]
+    end
+  end
+
+  method :middle do
+    test do
+      %w{W o r l d}.middle.assert == ['r']
+      %w{W o r l d y}.middle.assert == ['r', 'l']
+    end
+  end
+
+  method :middle do
+    test do
+      [1,2,3,4,5].middle(1).assert == [2,3,4]
+      [1,2,3,4,5,6].middle(1).assert == [2,3,4,5]
+    end
+  end
+
+  method :from do
+    test do
+      %w{W o r l d}.from(3).assert == %w{l d}
+    end
+  end
+
+  method :thru  do
+    test "single parameter" do
+      a = [1,2,3,4,5]
+      r = a.thru(3)
+      r.assert == [1,2,3,4]
+    end
+
+    test "dual parameter" do
+      a = [1,2,3,4,5]
+      r = a.thru(3,4)
+      r.assert == [4,5]
+    end
+
+    test do
+      [0,1,2,3,4,5].thru(2,4).assert == [2,3,4]
+      [0,1,2,3,4,5].thru(0,1).assert == [0,1]
+    end
+  end
+
+  # to be deprecated
+  method :index_of do
+    test do
+      [1,2,3,4].index_of{ |e| e == 3 }.assert == 2
+      [1,2,3,4].index_of{ |e| e > 3 }.assert == 3
+    end
+  end
+
+  method :first= do
+    test do
+      a = [1,2,3]
+      a.first = 9
+      a.assert == [9,2,3]
+    end
+  end
+
+  method :last= do
+    test do
+      a = [1,2,3]
+      a.last = 9
+      a.assert == [1,2,9]
+    end
+  end
+
+  method :ends do
+    test do
+      [1,2,3,4,5].ends.assert == 4
+    end
+  end
+
+  method :last_index do
+    test do
+      [1,2,3,4,5].last_index.assert == 4
+    end
+  end
+
+  method :pos do
+    test do
+      [1,2,3,4,5].pos(1).assert == 0
+      [1,2,3,4,5].pos(-1).assert == 4
+    end
+  end
+
+  method :range do
+    test do
+      ['a','b','c','d'].range.assert == (0..3)
+      ['a','b','c','d'].range('b','d').assert == (1..3)
+    end
+  end
+
+  method :range do
+    test do
+      a = [1,2,3,4,5]
+      b = [1,2,3,4,5,6]
+      a.range.assert == (0..4)
+      b.range.assert == (0..5)
+      a.range(2,4).assert == (1..3)
+      b.range(2,3).assert == (1..2)
+      b.range(4,2).assert == (3..1)
+    end
+  end
+
+  # We can't use an Array to test the following methods b/c
+  # Array handles them specially, either for efficency reasons,
+  # or becuase the have been added to Ruby as of 1.8.7+.
+
+  setup "special Indexable object" do
+    @c = Class.new do
+      include Indexable
+      def initialize(*a); @a = a; end
+      def slice(*a)  ; @a.slice(*a)  ; end
+      def splice(*a) ; @a.splice(*a) ; end
+      def size       ; @a.size       ; end
+      def to_a       ; @a            ; end
+    end
+  end
+
+  method :first do
+    test do
+      a = @c.new(1,2,3,4,5)
+      r = a.first(3)
+      r.assert == [1,2,3]
+    end
+  end
+
+  method :last do
+    test do
+      a = @c.new(1,2,3,4,5)
+      r = a.last(3)
+      r.assert == [3,4,5]
+    end
+  end
+
+  method :first! do
+    test do
+      a = @c.new(1,2,3,4,5)
+      e = a.first!
+      e.assert == 1
+      a.to_a.assert == [2,3,4,5]
+    end
+  end
+
+  method :last! do
+    test do
+      a = @c.new(1,2,3,4,5)
+      e = a.last!
+      e.assert == 5
+      a.to_a.assert == [1,2,3,4]
+    end
+  end
+
+  method :index do
+    test do
+      @c.new(1,2,3,4).index{ |e| e == 3 }.assert == 2
+      @c.new(1,2,3,4).index{ |e| e > 3 }.assert == 3
+    end
+  end
+
+  #method :[] do
+  #  test do
+  #    a = ['a','b','c','d','e','f']
+  #    assert_equal( ['b','f'], a[[1,-1]] )
+  #  end
+  #end
+
+  #method :[]= do
+  #  test do
+  #    a = ['a','o','z']
+  #    a[[0,2]] = ['A','Z']
+  #    assert_equal( ['A','o','Z'], a )
+  #    a[[0,-1]] = ['W','Y']
+  #    assert_equal( ['W','o','Y'], a )
+  #  end
+  #end
+
+end

data/test/core/integer/test_bitmask.rb

@@ -0,0 +1,73 @@
+covers 'facets/integer/bitmask'
+
+test_case Integer do
+
+  method :bit do
+    test do
+      0.bit(0).assert == 1
+      0.bit(1).assert == 2
+      0.bit(2).assert == 4
+      0.bit(3).assert == 8
+    end
+  end
+
+  method :bit do
+    test "negate" do
+      1.bit(~0).assert == 0
+      2.bit(~1).assert == 0
+      4.bit(~2).assert == 0
+      8.bit(~3).assert == 0
+    end
+  end
+
+  method :bit_clear do
+    test do
+      1.bit_clear(0).assert == 0
+      2.bit_clear(1).assert == 0
+      4.bit_clear(2).assert == 0
+      8.bit_clear(3).assert == 0
+    end
+  end
+
+  method :bit? do
+    test do
+      a = 8
+      assert(! a.bit?(0))
+      assert(! a.bit?(1))
+      assert(! a.bit?(2))
+      assert(  a.bit?(3))
+      assert(! a.bit?(4))
+      assert(! a.bit?(5))
+    end
+  end
+
+  method :bitmask do
+    test do
+      a =  1
+      m = Bit(4)
+      a = a.bitmask(m)
+      a.assert == 17
+      assert( a.bitmask?(m) )
+    end
+  end
+
+  method :bitmask? do
+    test do
+      7.assert.bitmask?(7)
+      7.assert.bitmask?(5)
+      8.refute.bitmask?(3)
+    end
+  end
+
+end
+
+test_case Kernel do
+
+  method :Bit do
+    test do
+      n = Bit(4)
+      n.assert == 16
+    end
+  end
+
+end

data/test/core/integer/test_factorial.rb

@@ -0,0 +1,30 @@
+covers 'facets/integer/factorial'
+
+test_case Integer do
+
+  method :factorial do
+
+    test do
+      0.factorial.assert == 1
+      1.factorial.assert == 1
+      2.factorial.assert == 2
+      3.factorial.assert == 6
+      4.factorial.assert == 24
+    end
+
+  end
+
+  method :fac do
+
+    test do
+      0.fac.assert == 1
+      1.fac.assert == 1
+      2.fac.assert == 2
+      3.fac.assert == 6
+      4.fac.assert == 24
+    end
+
+  end
+
+end
+

data/test/core/integer/test_multiple.rb

@@ -0,0 +1,16 @@
+covers 'facets/integer/multiple'
+
+test_case Integer do
+
+  method :multiple? do
+
+    test do
+      assert( ! 1.multiple?(2) )
+      assert(   2.multiple?(2) )
+      assert( ! 5.multiple?(3) )
+      assert(   6.multiple?(3) )
+    end
+
+  end
+
+end

data/test/core/integer/test_of.rb

@@ -0,0 +1,36 @@
+covers 'facets/integer/of'
+
+test_case Integer do
+
+  method :of do
+
+    test do
+      a = 4
+      b = a.of{ |i| i*2 }
+      b.assert == [0,2,4,6]
+    end
+
+  end
+
+  method :times_collect do
+
+    test do
+      a = 4
+      b = a.times_collect{ |i| i*2 }
+      b.assert == [0,2,4,6]
+    end
+
+  end
+
+  method :times_map do
+
+    test do
+      a = 4
+      b = a.times_map{ |i| i*2 }
+      b.assert == [0,2,4,6]
+    end
+
+  end
+
+end
+

data/test/core/integer/test_ordinal.rb

@@ -0,0 +1,27 @@
+covers 'facets/integer/ordinal'
+
+test_case Integer do
+
+  method :ordinal do
+
+    test do
+      1.ordinal.assert == '1st'
+      2.ordinal.assert == '2nd'
+      3.ordinal.assert == '3rd'
+      4.ordinal.assert == '4th'
+    end
+
+  end
+
+  method :ordinalize do
+
+    test do
+      1.ordinalize.assert == '1st'
+      2.ordinalize.assert == '2nd'
+      3.ordinalize.assert == '3rd'
+      4.ordinalize.assert == '4th'
+    end
+
+  end
+
+end

data/test/core/kernel/test_as.rb

@@ -0,0 +1,74 @@
+covers 'facets/kernel/as'
+
+test_case Kernel do
+
+  setup "class heirarchy" do
+    a = Class.new do
+      def x; "a.x"; end
+      def y; "a.y"; end
+    end
+    b = Class.new(a) do
+      def x; "b.x" end
+      def y; "b.y" end
+    end
+    c = Class.new(b) do
+      def x; "c.x"; end
+      define_method(:y){ as(a).x }
+    end
+    @a, @b, @c = a, b, c
+  end
+
+  method :as do 
+
+    test do
+      o = @c.new
+      o.x.assert == "c.x"
+      o.y.assert == "a.x"
+    end
+
+  end
+
+  method :send_as do
+
+    test do
+      s = "a"
+      def s.class; nil; end
+      s.class.refute == String
+      s.send_as(Object, :class).assert == String
+    end
+
+  end
+
+  #setup "class heirarchy" do
+  #  x = Class.new{ def x ; 1 ; end }
+  #  y = Class.new(x){ def x ; 2 ; end }
+  #  z = Class.new(y){ define_method(:x){ super_as(x) } }
+  #  z
+  #end
+
+  #method :super_as do |z|
+  #  o = z.new
+  #  o.x.assert == 1
+  #end
+
+end
+
+test_case As do
+
+  class_method :new do
+
+    setup do
+      @c = Class.new(String) do
+             def to_s; "denied"; end
+           end
+    end
+
+    test do
+      o = @c.new("hi")
+      o.to_s.assert == "denied"
+      As.new(o, String).to_s.assert == "hi"
+    end
+
+  end
+
+end

data/test/core/kernel/test_ask.rb

@@ -0,0 +1,9 @@
+covers 'facets/kernel/ask'
+
+test_case Kernel do
+
+  # requires user input
+  method :ask do
+  end
+
+end