facets 3.1.0 → 3.2.0

data/test/core/hash/test_zip.rb

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

@@ -1,226 +0,0 @@
-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 :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

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

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

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

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

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

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

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

data/test/core/kernel/test_assign.rb

@@ -1,61 +0,0 @@
-covers 'facets/kernel/assign'
-
-test_case Kernel do
-
-  method :assign do
-
-    setup do
-      @c = Struct.new(:name, :address, :zip)
-    end
-
-    test "with arguments" do
-      bob = @c.new
-
-      bob.assign(:name, "Bob Sawyer")
-      bob.assign(:address, "123 Maple, Anytown NC")
-      bob.assign(:zip, 12345)
-
-      bob.name.assert == "Bob Sawyer"
-      bob.address.assert == "123 Maple, Anytown NC"
-      bob.zip.assert == 12345
-    end
-
-    test "with hash" do
-      bob = @c.new
-
-      x = { :name => "Bob Sawyer", :address => "123 Maple, Anytown NC", :zip => 12345 }
-
-      bob.assign(x)
-
-      bob.name.assert == x[:name]
-      bob.address.assert == x[:address]
-      bob.zip.assert == x[:zip]
-    end
-
-    test "with associative array" do
-      bob = @c.new
-
-      x = [[:name, "Bob Sawyer"], [:address, "123 Maple, Anytown NC"], [:zip, 12345]]
-
-      bob.assign(x)
-
-      bob.name.assert == "Bob Sawyer"
-      bob.address.assert == "123 Maple, Anytown NC"
-      bob.zip.assert == 12345
-    end
-
-    #test "with block" do
-    #  bob = @c.new
-    #
-    #  x = lambda {|s| s.name = "Bob Sawyer"; s.address = "123 Maple, Anytown NC"; s.zip = 12345 }
-    #
-    #  bob.assign(&x)
-    #
-    #  bob.name.assert == "Bob Sawyer"
-    #  bob.address.assert == "123 Maple, Anytown NC"
-    #  bob.zip.assert == 12345
-    #end
-
-  end
-
-end

data/test/core/kernel/test_assign_from.rb

@@ -1,48 +0,0 @@
-covers 'facets/kernel/assign_from'
-
-test_case Kernel do
-
-  c = Struct.new(:name, :address, :zip)
-
-  method :assign_from do
-
-    test do
-      bob = c.new("Bob Sawyer", "123 Maple, Anytown NC", 12345)
-      joe = c.new("Joe Pitare")
-
-      joe.assign_from(bob, :address, :zip)
-
-      joe.name.assert == "Joe Pitare"
-      joe.address. == "123 Maple, Anytown NC"
-      joe.zip.assert == 12345
-    end
-
-  end
-
-  method :assign_from do
-
-    c1 = Class.new do
-      attr_accessor :a
-      attr_accessor :b
-    end
-
-    c2 = Class.new do
-      attr_accessor :a
-      attr_accessor :b
-    end
-
-    test do
-      o1 = c1.new
-      o1.a = 1
-      o1.b = 2
-
-      o2 = c2.new
-      o2.assign_from(o1, :a, :b)
-
-      o2.a.assert == 1
-      o2.b.assert == 2
-    end
-
-  end
-
-end

data/test/core/kernel/test_attr_singleton.rb

@@ -1,51 +0,0 @@
-covers 'facets/kernel/attr_singleton'
-
-test_case Kernel do
-
-  c = Class.new do
-    def initialize
-      attr_singleton_reader :foo #=> "FOO"
-      attr_singleton_writer :bar #=> "BAR"
-      attr_singleton_accessor :baz #=> "BAZ"
-      @foo = "FOO"
-      self.bar = "BAR"
-      self.baz = "BAZ"
-    end
-    def get_bar
-      @bar
-    end
-  end
-
-  method :attr_singleton_reader do
-
-    test do
-      t = c.new
-      t.foo.assert == "FOO"
-    end
-
-  end
-
-  method :attr_singleton_writer do
-
-    test do
-      t = c.new
-      t.get_bar.assert == "BAR"
-      t.bar = "BAR2"
-      t.get_bar.assert == "BAR2"
-    end
-
-  end
-
-  method :attr_singleton_accessor do
-
-    test do
-      t = c.new
-      t.baz.assert == "BAZ"
-      t.baz = "BAZ2"
-      t.baz.assert == "BAZ2"
-    end
-
-  end
-
-end
-