Add bin and edit workflow

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/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

bin/gems/facets-3.1.0/test/core/kernel/test_assign.rb

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

bin/gems/facets-3.1.0/test/core/kernel/test_assign_from.rb

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

bin/gems/facets-3.1.0/test/core/kernel/test_attr_singleton.rb

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

bin/gems/facets-3.1.0/test/core/kernel/test_blank.rb

@@ -0,0 +1,103 @@
+covers 'facets/kernel/blank'
+
+# NOTE: Using x.assert.blank? here caused AE some issues
+# b/c of problems with Assertor. Basically Assertor needs
+# to subclass BasicObject, but Ruby 1.9 has constant lookup
+# issues with BasicObject that need address. So in this case
+# we'll just use the old-school `assert foo` syntax.
+
+test_case Kernel do
+
+  method :blank? do
+    test do
+      refute Object.new.blank?
+    end
+  end
+
+end
+
+test_case NilClass do
+
+  method :blank? do
+    test do
+      assert nil.blank?
+    end
+  end
+
+end
+
+test_case FalseClass do
+
+  method :blank? do
+    test do
+      assert false.blank?
+    end
+  end
+
+end
+
+test_case TrueClass do
+
+  method :blank? do
+    test do
+      refute true.blank?
+    end
+  end
+
+end
+
+test_case Array do
+
+  method :blank? do
+    test do
+      assert [].blank?
+      refute [1].blank?
+    end
+  end
+
+end
+
+test_case Hash do
+
+  method :blank? do
+    test do
+      assert( {}.blank? )
+      refute( {:a=>1}.blank? )
+    end
+  end
+
+end
+
+test_case String do
+
+  method :blank? do
+    test do
+      refute "xyz".blank?
+      assert "   ".blank?
+    end
+  end
+
+end
+
+test_case Numeric do
+
+  method :blank? do
+    test do
+      refute 0.blank?
+    end
+  end
+
+  method :blank? do
+    test do
+      refute 10.blank?
+    end
+  end
+
+  method :blank? do
+    test do
+      refute 10.0.blank?
+    end
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_callstack.rb

@@ -0,0 +1,21 @@
+covers 'facets/kernel/callstack'
+
+test_case Kernel do
+
+  method :call_stack do
+
+    test do
+      call_stack
+    end
+
+  end
+
+  method :callstack do
+
+    test do
+      callstack
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_class.rb

@@ -0,0 +1,14 @@
+covers 'facets/kernel/__class__'
+
+test_case Kernel do
+
+  method :__class__ do
+
+    test do
+      o = Object.new
+      o.__class__.assert == o.class
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_complete.rb

@@ -0,0 +1,19 @@
+covers 'facets/kernel/complete'
+
+test_case Kernel do
+
+  method :complete do
+
+    test do
+      a = []
+      i = 0
+      complete do
+        i += 1
+        i == 3 ? nil : a << i
+      end
+      a.assert == [1,2]
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_constant.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/constant'
+
+test_case Kernel do
+
+  method :constant do
+
+    test do
+      c = ::Lemon::TestCase.name
+      constant(c).assert == ::Lemon::TestCase
+
+      c = "TestCase"
+      ::Lemon.constant(c).assert == ::Lemon::TestCase
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_d.rb

@@ -0,0 +1,10 @@
+covers 'facets/kernel/d'
+
+test_case Kernel do
+
+  # TODO: how to test #d silently? Need to redirect $stderr.
+
+  method :d do
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_deep_clone.rb

@@ -0,0 +1,31 @@
+covers 'facets/kernel/deep_clone'
+
+test_case Kernel do
+
+  method :deep_clone do
+
+    setup "a class with reference to another class" do
+      xC = Class.new do
+        attr_reader :x
+        def initialize
+          @x = 1
+        end
+      end
+
+      @c = Class.new do
+        attr_reader :y
+        define_method(:initialize) do
+          @y = xC.new
+        end
+      end
+    end
+
+    test do
+      o = @c.new
+      d = o.deep_clone
+      d.y.x.assert == 1
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_deep_copy.rb

@@ -0,0 +1,15 @@
+covers 'facets/kernel/deep_copy'
+
+test_case Kernel do
+
+  method :deep_copy do
+
+    test do
+      o = "This is a weak test."
+      d = o.deep_copy
+      d.assert == "This is a weak test."
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_dir.rb

@@ -0,0 +1,24 @@
+covers 'facets/kernel/__dir__'
+
+test_case Kernel do
+
+  # TODO: can't test b/c somehow Lemon intefers with the call stack
+  # which __DIR__ uses to locate the current running file.
+
+  method :__DIR__ do
+
+    omit "issue with call stack" do
+
+      test "relative directory" do
+        __DIR__.assert == File.dirname(__FILE__)
+      end
+
+      test  "relative directory joins with arguments" do
+        __DIR__('tmp').assert == File.join(File.dirname(__FILE__), 'tmp')
+      end
+
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_disable_warnings.rb

@@ -0,0 +1,38 @@
+covers 'facets/kernel/disable_warnings'
+covers 'facets/kernel/enable_warnings'
+covers 'facets/kernel/silence_warnings'
+
+test_case Kernel do
+
+  method :disable_warnings do
+
+    test do
+      disable_warnings do
+        assert( ! $VERBOSE )
+      end
+    end
+
+  end
+
+  method :silence_warnings do
+
+    test "alias for backward compatibility" do
+      silence_warnings do
+        assert( ! $VERBOSE )
+      end
+    end
+
+  end
+
+  method :enable_warnings do
+
+    test :enable_warnings do
+      enable_warnings do
+        assert( $VERBOSE )
+      end
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_ergo.rb

@@ -0,0 +1,34 @@
+covers 'facets/kernel/ergo'
+
+test_case Kernel do
+
+  method :ergo do
+
+    test do
+      "a".ergo.upcase.assert == "A"
+      nil.ergo.foobar.assert == nil
+
+    end
+
+    test do
+      "a".ergo { |o| o.upcase }.assert == "A"
+      nil.ergo { |o| o.foobar }.assert == nil
+    end
+
+  end
+
+end
+
+test_case NilClass do
+
+  method :ergo do
+
+    test do
+      "a".ergo { |o| o.upcase }.assert   == "A"
+      nil.ergo { |o| o.bar }.assert      == nil
+      nil.ergo.ergo { |o| o.bar }.assert == nil
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_extension.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/extension'
+
+test_case Kernel do
+
+  # DEPRECATE ?
+  method :extension do
+
+    test do
+      c = Class.new
+      o = c.new
+      x = (class << o; self; end)
+      o.extension.assert == x
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_get.rb

@@ -0,0 +1,54 @@
+covers 'facets/kernel/__get__'
+covers 'facets/kernel/__set__'
+
+test_case Kernel do
+
+  method :__get__ do
+
+    setup "an object with an instance variable" do
+      c = Class.new do
+        attr :a
+        def initialize
+          @a = 1
+        end
+      end
+      @o = c.new
+    end
+
+    test do
+      @o.__get__('@a').assert == 1
+    end
+
+    # TODO: support is being considered
+    #test "wihtout at-sign" do |o|
+    #  o.__get__(:a).assert == 1
+    #end
+
+  end
+
+  method :__set__ do
+
+    setup "an object with an instance variable" do
+      c = Class.new do
+        attr :a
+        def initialize
+          @a = 1
+        end
+      end
+      @o = c.new
+    end
+
+    test do
+      @o.__set__('@a', 2)
+      @o.a.assert == 2
+    end
+
+    # TODO: support is being considered
+    #test "without at-sign" do
+    #  @o.__set__(:a, 3)
+    #  @o.a.assert == 3
+    #end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_here.rb

@@ -0,0 +1,13 @@
+covers 'facets/kernel/here'
+
+test_case Kernel do
+
+  method :here do
+
+    test do
+      here.assert.is_a?(Binding)
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/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
+

bin/gems/facets-3.1.0/test/core/kernel/test_in.rb

@@ -0,0 +1,14 @@
+covers 'facets/kernel/in'
+
+test_case Kernel do
+
+  method :in? do
+
+    test do
+      5.assert.in?(0..10)
+      5.assert.in?([1,2,3,4,5])
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_instance_assign.rb

@@ -0,0 +1,19 @@
+covers 'facets/kernel/instance_assign'
+
+test_case Kernel do
+
+  method :instance_assign do
+
+    test do
+      ahash = { "z"=>0, "@a"=>1, "@b"=>2 } #, "@@a"=>3 }
+      instance_assign(ahash)
+      @z.assert == 0
+      @a.assert == 1
+      @b.assert == 2
+      #@@a.assert == 3
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_instance_class.rb

@@ -0,0 +1,15 @@
+covers 'facets/kernel/instance_class'
+
+test_case Kernel do
+
+  method :instance_class do
+
+    test do
+      o = Object.new
+      o.instance_class.assert == (class << o; self; end)
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_instance_extract.rb

@@ -0,0 +1,28 @@
+covers 'facets/kernel/instance_extract'
+ 
+test_case Kernel do 
+
+   method :instance_extract do
+
+     test "extracts hash into object" do
+       c = Class.new do
+         def initialize
+           @cmd='cls'
+         end
+         def cmd
+           @cmd
+         end
+         def page
+           @page
+         end
+       end
+ 
+       o = c.new
+       o.instance_extract('cmd'=>'hello','page'=>'frontpage')
+       o.cmd.assert == 'cls'
+       o.page.assert == 'frontpage'
+     end
+
+   end
+
+ end

bin/gems/facets-3.1.0/test/core/kernel/test_instance_replace.rb

@@ -0,0 +1,47 @@
+covers 'facets/kernel/instance_replace'
+test_case Kernel do
+
+  method :instance_replace do
+
+    test "must be the same type" do
+      c = Class.new do
+        attr_reader :a, :b
+        def initialize(a,b)
+          @a, @b = a, b
+        end
+      end
+
+      o = c.new(1,2)
+      o.a.assert == 1
+      o.b.assert == 2
+
+      # TODO: TypeError ?
+      expect ArgumentError do
+        o.instance_replace(:a=>3, :b=>4)
+      end
+    end
+
+    test do
+      c = Class.new do
+        attr :name
+        attr :age
+        def initialize(name, age)
+          @name, @age = name, age
+        end
+      end
+
+      a = c.new('bob', 60)
+      a.name.assert == 'bob'
+      a.age.assert == 60
+
+      b = c.new('tom', 40)
+
+      a.instance_replace(b)
+
+      a.name.assert == 'tom'
+      a.age.assert == 40
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_instance_send.rb

@@ -0,0 +1,26 @@
+covers 'facets/kernel/instance_send'
+
+test_case Kernel do
+
+  method :instance_send do
+
+    test "alias for #send" do
+      c = Class.new do
+        def x; "x"; end
+        private
+        def y; "y"; end
+      end
+
+      o = c.new
+
+      expect NoMethodError do
+        o.y
+      end
+
+      o.instance_send(:x).assert == "x"
+      o.instance_send(:y).assert == "y"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_maybe.rb

@@ -0,0 +1,13 @@
+covers 'facets/kernel/maybe'
+
+test_case Kernel do
+
+  method :maybe do
+
+    test do
+      maybe
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_meta_alias.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/meta_alias'
+
+test_case Kernel do
+
+  method :meta_alias do
+
+    test do
+      c = Class.new do
+        def self.y?; "y?" ; end
+      end
+      c.meta_alias "ynot?", "y?"
+      c.ynot?.assert == "y?"
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_meta_class.rb

@@ -0,0 +1,33 @@
+covers 'facets/kernel/meta_class'
+
+test_case Kernel do
+
+  method :meta_class do
+
+    test do
+      x = Class.new
+      m = (class << x; self; end)
+      x.meta_class.assert == m
+    end
+
+    test "class_eval block on meta class" do
+      c = Class.new
+      c.meta_class do
+        def foo; "foo"; end
+      end
+      c.foo.assert == "foo"
+    end
+
+  end
+
+  method :metaclass do
+
+    test do
+      x = Class.new
+      m = (class << x; self; end)
+      x.metaclass.assert == m
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_meta_def.rb

@@ -0,0 +1,15 @@
+covers 'facets/kernel/meta_def'
+
+test_case Kernel do
+
+  method  :meta_def do
+
+    test do
+      x = Class.new
+      x.meta_def(:x){"x"}
+      x.x.assert == "x"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_meta_eval.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/meta_eval'
+
+test_case Kernel do
+
+  method :meta_eval do
+
+    test do
+      o = Object.new
+      o.meta_eval do
+        @y = "y"
+      end
+      o.instance_variable_get("@y").refute == "y"
+      (class << o; self; end).instance_variable_get("@y").assert == "y"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_method.rb

@@ -0,0 +1,20 @@
+covers 'facets/kernel/method'
+
+test_case Kernel do
+
+  method :method! do
+
+    test do
+      c = Class.new do
+        def foo ; 'foo' ; end
+      end
+
+      ic = c.new
+      ic.method(:foo).__id__.refute == ic.method(:foo).__id__
+      ic.method!(:foo).__id__.assert == ic.method!(:foo).__id__
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_not.rb

@@ -0,0 +1,51 @@
+covers 'facets/kernel/not'
+
+test_case Kernel do
+
+  method :not? do
+
+    test do
+      b = true
+      b.not?.assert == !b
+    end
+
+    test :not? do
+      b = false
+      b.not?.assert == !b
+    end
+
+    test :not? do
+      b = nil
+      b.not?.assert == !b
+    end
+
+    test :not? do
+      b = Object.new
+      b.not?.assert == !b
+    end
+
+  end
+
+  method :not do
+
+    test do
+      b = true
+      r = b.not.nil?
+      r.assert == true
+    end
+
+    test :not do
+      b = false
+      r = b.not.nil?
+      r.assert == true
+    end
+
+    test :not do
+      b = nil
+      r = b.not.nil?
+      r.assert == false
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_not_nil.rb

@@ -0,0 +1,25 @@
+covers 'facets/kernel/not_nil'
+
+test_case Kernel do
+
+  method :not_nil? do
+
+    test do
+      5.assert.not_nil?
+    end
+
+    test do
+      :x.assert.not_nil?
+    end
+
+    test do
+      false.assert.not_nil?
+    end
+
+    test do
+      nil.refute.not_nil?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_object_class.rb

@@ -0,0 +1,22 @@
+covers 'facets/kernel/object_class'
+covers 'facets/kernel/__class__'
+
+test_case Kernel do
+
+  method :object_class do
+
+    test do
+      self.object_class.assert == self.class
+    end
+
+  end
+
+  method :__class__ do
+
+    test do
+      self.__class__.assert == self.class
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_object_hexid.rb

@@ -0,0 +1,20 @@
+covers 'facets/kernel/object_hexid'
+
+test_case Kernel do
+
+  method :object_hexid do
+
+    omit "too inconsitent across platforms" do
+
+      test do
+        o = Object.new
+        "#<Object:#{o.object_hexid}>".assert == o.inspect
+        #assert(o.inspect.index(o.object_hexid))
+      end
+
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_object_send.rb

@@ -0,0 +1,25 @@
+covers 'facets/kernel/object_send'
+
+test_case Kernel do
+
+  method :object_send do
+
+    test "same as #public_send of Ruby 1.9+" do
+      c = Class.new do
+        def x; "x"; end
+        private
+        def y; "y"; end
+      end
+
+      o = c.new
+
+      o.object_send(:x).assert == "x"
+
+      expect NoMethodError do
+        o.object_send(:y)
+      end
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_presence.rb

@@ -0,0 +1,37 @@
+covers 'facets/kernel/presence'
+
+test_case Kernel do
+
+  method :presence do
+
+    test do
+      "a".presence.assert == "a"
+      [1].presence.assert == [1]
+      {:a=>1}.presence.assert == {:a=>1}
+    end
+
+    test do
+      "".presence.assert == nil
+      [].presence.assert == nil
+      {}.presence.assert == nil
+    end
+
+  end
+
+  method :present? do
+
+    test "non-empty objects are present" do
+      "a".assert.present?
+      [1].assert.present?
+      {:a=>1}.assert.present?
+    end
+
+    test "empty object are not present" do
+      "".refute.present?
+      [].refute.present?
+      {}.refute.present?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_qua_class.rb

@@ -0,0 +1,25 @@
+covers 'facets/kernel/qua_class'
+
+test_case Kernel do
+
+  method :qua_class do
+
+    test do
+      o = Object.new
+      s = (class << o; self; end)
+      o.qua_class.assert == s
+    end
+
+  end
+
+  method :quaclass do
+
+    test do
+      o = Object.new
+      s = (class << o; self; end)
+      o.quaclass.assert == s
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_require_all.rb

@@ -0,0 +1,11 @@
+covers 'facets/kernel/require_all'
+
+test_case Kernel do
+
+  method :require_all do
+  end
+
+  method :load_all do
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_respond.rb

@@ -0,0 +1,38 @@
+covers 'facets/kernel/respond'
+
+test_case Kernel do
+
+  method :respond do
+
+    test do
+      c = Class.new do
+        def f; "f"; end
+      end
+    
+      x = c.new
+      x.respond(:f).assert == "f"
+      x.respond(:g).assert == nil
+
+      x.respond.f.assert == "f"
+      x.respond.g.assert == nil
+    end
+
+  end
+
+  #
+  #method :respond_with_value do
+  #  test do
+  #    c = Class.new do
+  #      def f; "f"; end
+  #    end
+  #
+  #    x = c.new
+  #    x.respond_with_value(:f).assert == "f"
+  #    x.respond_with_value(:g).assert == nil
+  #
+  #    x.respond_with_value.f.assert == "f"
+  #    x.respond_with_value.g.assert == nil
+  #  end
+  #end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_returning.rb

@@ -0,0 +1,17 @@
+covers 'facets/kernel/returning'
+
+test_case Kernel do
+
+  method :returning do
+
+    test do
+      foo = returning( values = [] ) do
+        values << 'bar'
+        values << 'baz'
+      end
+      foo.assert == ['bar', 'baz']
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_silence.rb

@@ -0,0 +1,24 @@
+covers 'facets/kernel/silence'
+
+test_case Kernel do
+
+  # TODO: figure out how to test silence methods
+
+  concern "Not straight foward to test since they effect output."
+
+  method :silence do
+  end
+
+  method :silence_stream do
+  end
+
+  method :silence_stderr do
+  end
+
+  method :silence_stdout do
+  end
+
+  method :silently do
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_singleton_class.rb

@@ -0,0 +1,15 @@
+covers 'facets/kernel/singleton_class'
+
+test_case Kernel do
+
+  method :singleton_class do
+
+    test do
+      x = Class.new
+      m = (class << x; self; end)
+      x.singleton_class.assert == m
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_super_method.rb

@@ -0,0 +1,23 @@
+covers 'facets/kernel/super_method'
+
+test_case Kernel do
+
+  method :super_method do
+
+    setup "class heirarchy" do
+      @x = Class.new{ def x ; 1 ; end }
+      @y = Class.new(@x){ def x ; 2 ; end }
+      @z = Class.new(@y){ def x ; 3 ; end }
+    end
+
+    test do
+      x = @x.new
+      z = @z.new
+      s0 = x.method(:x)
+      s1 = z.super_method(@x, :x)
+      s1.call.assert == s0.call
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_tap.rb

@@ -0,0 +1,38 @@
+covers 'facets/kernel/tap'
+
+test_case Kernel do
+
+  method :tap do
+
+    test do
+      e = "foo"
+      r = "foobar".tap{ |x| x.gsub!(/bar/, '') }
+      r.assert == e
+    end
+
+    test "check internal value" do
+      x = [1,2,3]
+      x.tap{ |a|
+        a.assert == x
+      }
+    end
+
+    test "assign via tap block" do
+      bob = Struct.new(:name, :address, :zip).new
+
+      x = lambda do |s|
+        s.name    = "Bob Sawyer"
+        s.address = "123 Maple, Anytown NC"
+        s.zip     = "12345" 
+      end
+
+      bob.tap(&x)
+
+      bob.name.assert == "Bob Sawyer"
+      bob.address.assert == "123 Maple, Anytown NC"
+      bob.zip.assert == "12345"
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_temporarily.rb

@@ -0,0 +1,25 @@
+covers 'facets/kernel/temporarily'
+
+test_case Kernel do
+
+  method :temporarily do
+
+    test "global variable" do
+      $temporary_variable = true
+      temporarily('$temporary_variable'=>false) do
+        $temporary_variable.assert == false
+      end
+      $temporary_variable.assert == true
+    end
+
+    test "instance variable" do
+      @x = 1
+      temporarily('@x'=>2) do
+        @x.assert == 2
+      end
+      @x.assert == 1
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_true.rb

@@ -0,0 +1,31 @@
+covers 'facets/kernel/true'
+
+test_case Kernel do
+
+  method :true? do
+
+    test "nothing is true? but true itself" do
+      true.assert.true?
+
+      nil.refute.true?
+      false.refute.true?
+      1.refute.true?
+      :a.refute.true?
+    end
+
+  end
+
+  method :false? do
+
+    test "nothing is false? but false itself" do
+      false.assert.false?
+
+      nil.refute.false?
+      true.refute.false?
+      1.refute.false?
+      :a.refute.false?
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_try.rb

@@ -0,0 +1,35 @@
+covers 'facets/kernel/try'
+
+test_case Kernel do
+
+  method :try do
+
+    test do
+      example = Struct.new(:name).new("bob")
+      example.try(:name).assert == "bob"
+    end
+
+    test "without argument" do
+      example = Struct.new(:name).new("bob")
+      example.try.name.assert == "bob"
+    end
+
+  end
+
+end
+
+test_case NilClass do
+
+  method :try do
+
+    test do
+      nil.try(:name).assert == nil
+    end
+
+    test "without argument" do
+      nil.try.name.assert == nil
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_val.rb

@@ -0,0 +1,30 @@
+covers 'facets/kernel/val'
+
+test_case Kernel do
+
+  method :val? do
+
+    test "of nil" do
+      f = nil
+      t = 1
+      f.refute.val?
+      t.assert.val?
+    end
+
+    test "of empty array" do
+      f = []
+      t = [1]
+      f.refute.val?
+      t.assert.val?
+    end
+
+    test "of empty string" do
+      f = ''
+      t = '1'
+      f.refute.val?
+      t.assert.val? 
+    end
+
+  end
+
+end

bin/gems/facets-3.1.0/test/core/kernel/test_with.rb

@@ -0,0 +1,18 @@
+covers 'facets/kernel/with'
+
+test_case Kernel do
+
+  method :with do
+
+    test do
+      with values = [] do
+        self << 'bar'
+        self << 'baz'
+      end
+      values.assert == ['bar', 'baz']
+    end
+
+  end
+
+end
+

bin/gems/facets-3.1.0/test/core/kernel/test_writers.rb

@@ -0,0 +1,53 @@
+covers 'facets/kernel/writers'
+
+test_case Kernel do
+
+  method :writers do
+
+    test do
+      c = Class.new do
+        attr_accessor :a
+        def b=(b); @b=b; end
+      end
+      o = c.new
+      w = o.writers
+
+      w.assert.include?(:a=)
+      w.assert.include?(:b=)
+    end
+
+    test do
+      c = Class.new do
+        attr_accessor :a
+        def b=(b); @b=b; end
+        private
+        def q=(q); @q=q; end
+      end
+      o = c.new
+      w = o.writers(:access=>:private)
+
+      w.refute.include?(:a=)
+      w.refute.include?(:b=)
+      w.assert.include?(:q=)
+    end
+
+    test do
+      c = Class.new do
+        attr_accessor :a
+        def b=(b); @b=b; end
+        private
+        def q=(q); @q=q; end
+      end
+      o = c.new
+      w = o.writers(:access=>:all)
+
+      w.assert.include?(:a=)
+      w.assert.include?(:b=)
+      w.assert.include?(:q=)
+    end
+
+    # TODO: Need to test more options for writers.
+
+  end
+
+end