facets 2.1.3 → 2.2.0

data/lib/core/facets/kernel/constant.rb

@@ -1,12 +1,3 @@
-# TITLE:
-#
-#   Kernel Constant
-#
-# DESCRIPTION:
-#
-#   Get a constant. But more convenient than const_get.
-
-#
 module Kernel
 
   # This is similar to +Module#const_get+ but is accessible at all levels,
@@ -22,6 +13,8 @@ module Kernel
   #   Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
   #   Test.constant("::Test::Unit")       # -> Test::Unit
   #
+  #   CREDIT: Trans
+
   def constant(const)
     const = const.to_s.dup
     base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
@@ -29,32 +22,3 @@ module Kernel
   end
 
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCKernel < Test::Unit::TestCase
-
-    def test_constant
-      c = ::Test::Unit::TestCase.name
-      assert_equal( ::Test::Unit::TestCase, constant(c) )
-      c = "Test::Unit::TestCase"
-      assert_equal( ::Test::Unit::TestCase, constant(c) )
-      c = "Unit::TestCase"
-      assert_equal( ::Test::Unit::TestCase, Test.constant(c) )
-      c = "TestCase"
-      assert_equal( ::Test::Unit::TestCase, Test::Unit.constant(c) )
-    end
-
-  end
-
-=end

data/lib/core/facets/kernel/deepcopy.rb

@@ -1,19 +1,3 @@
-# TITLE:
-#
-#   Copy Extensions
-#
-# FILE:
-#
-#   kernel/copy.rb
-#
-# DESCRIPTION:
-#
-#   Kernel extensions for copying objects.
-#
-# AUTHORS:
-#
-#   CREDIT Jan Molic
-
 module Kernel
 
   # Anything that can be marshaled can be copied in totality.
@@ -25,7 +9,7 @@ module Kernel
     Marshal::load(Marshal::dump(self))
   end
 
-  alias deep_copy copy
+  alias_method :deep_copy, :copy
 
   # Adds deep_clone method to an object which produces deep copy of it. It means
   # if you clone a Hash, every nested items and their nested items will be cloned.
@@ -37,6 +21,8 @@ module Kernel
   #   obj.push( 'foo' )
   #   p obj   # >> [ 'foo' ]
   #   p b[2]  # >> []
+  #
+  #   CREDIT: Jan Molic
 
   def deep_clone( obj=self, cloned={} )
     if cloned.has_key?( obj.object_id )
@@ -71,41 +57,3 @@ module Kernel
   end
 
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestKernelCopy < Test::Unit::TestCase
-
-    # fixtures for copy / deep_copy
-    class A
-      attr_reader :a
-      def initialize
-        @a = 1
-      end
-    end
-
-    class B
-      attr_reader :b
-      def initialize
-        @b = A.new
-      end
-    end
-
-    def test_deep_copy
-      o = B.new
-      oc = o.deep_copy
-      assert_equal( 1, o.b.a  )
-    end
-
-  end
-
-=end

data/lib/core/facets/kernel/dir.rb

@@ -3,6 +3,8 @@ module Kernel
 
   # Similar to __FILE__ and __LINE__, __DIR__ provides
   # the directory path to the current executing script.
+  #
+  #  CREDIT: Trans
 
   def __DIR__
     (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil

data/lib/core/facets/kernel/ergo.rb

@@ -12,7 +12,7 @@ module Kernel
   #
   # This is like #tap, but tap yields self -and- returns self.
   #
-  # CREDIT Daniel DeLorme
+  #   CREDIT: Daniel DeLorme
 
   def ergo &b
     if block_given?
@@ -31,7 +31,7 @@ class NilClass
   #   "a".ergo{ |o| o.upcase } #=> "A"
   #   nil.ergo{ |o| o.bar } #=> nil
   #
-  # CREDIT Daniel DeLorme
+  #   CREDIT: Daniel DeLorme
 
   def ergo
     @_ergo ||= Functor.new{ nil }

data/lib/core/facets/kernel/instance.rb

@@ -1,43 +1,31 @@
-# TITLE:
-#
-#    Instance Methods
-#
-# FILE:
-#
-#   kernel/instance.rb
-#
-# DESCRIPTION:
-#
-#   Kernel extension prefixed by instance_ which provide
-#   internal (eg private) access to the object.
-#
-# AUTHORS:
-#
-#   CREDIT Thomas Sawyer
-#
-# NOTES:
-#
-#   TODO Should instance_assign be named instance_variable_assign?
-#        Likewise for instance_assume. Is there a better term than 'assume'?
-#
-#   TODO How to handle instance_exec? It's require proc/bind to work
-#        But that requires thread which we don't want to load automatically.
-#
-#   TODO Should the __shadow__ methods be defined elsewhere?
-
-require 'facets/proc/bind'
-
-#
+unless (RUBY_VERSION[0,3] == '1.9')
+  require 'facets/proc/bind'
+end
+
 module Kernel
+  #
+  # Kernel extension prefixed by instance_ which provide
+  # internal (eg private) access to the object.
+  #
+
+  unless (RUBY_VERSION[0,3] == '1.9')
+    # Like instance_eval but allows parameters to be passed.
+    #
+    #   TODO: Remove for Ruby 1.9.
+
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
+  end
 
   # Shadow method for instance_variable_get.
-  alias :__get__ :instance_variable_get
+  alias_method :__get__, :instance_variable_get
 
   # Shadow method for instance_variable_set.
-  alias :__set__ :instance_variable_set
+  alias_method :__set__, :instance_variable_set
 
   # Private send. Why isn't #send called instance_send in the first place?
-  alias :instance_send :send
+  alias_method :instance_send, :send
 
   # Easy access to an object qua class, otherwise known
   # as the object's metaclass or singleton class. This
@@ -46,16 +34,27 @@ module Kernel
   #
   #     It is what it is.
   #
-  #               -- 7rans0noma
-  #
+  #  CREDIT: Trans
+
   def instance_class( &block )
     (class << self; self; end).module_eval(&block) if block
     (class << self; self; end)
   end
 
-  # CREDIT David Heinemeier Hansson
-
   # Return instance variable values in an array.
+  #
+  #   class X
+  #     def initialize(a,b)
+  #       @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   x = X.new(1,2)
+  #
+  #   x.instance_values   #=> [1,2]
+  #
+  #   CREDIT: David Heinemeier Hansson
+
   def instance_values
     instance_variables.inject({}) do |values, name|
     values[name[1..-1]] = instance_variable_get(name)
@@ -63,12 +62,6 @@ module Kernel
     end
   end
 
-  # Like instace_eval but allows parameters to be passed.
-  #
-  def instance_exec(*arguments, &block)
-    block.bind(self)[*arguments]
-  end
-
   # Assign instance vars using another object.
   #
   #   class O
@@ -88,6 +81,8 @@ module Kernel
   #   o2.instance_eval{ @b }  #=> 2
   #   o2.instance_eval{ @c }  #=> 3
   #   o2.instance_eval{ @d }  #=> 4
+  #
+  #   CREDIT: Trans
 
   def instance_assume(obj, *vars)
     if vars.empty?
@@ -104,11 +99,17 @@ module Kernel
     return self  # ???
   end
 
-  # For backward compatability (DEPRECATED).
-  alias :assign_from :instance_assume
+  # For backward compatability (TO BE DEPRECATED).
+
+  def assign_from(*args)
+    warn "use instance_assume for a future version"
+    instance_assume(*args)
+  end
 
   # As with #instance_assume, but forces the setting of the object's
-  # instance varaibles even if the recieve doesn't have them defined.
+  # instance varaibles even if the reciever doesn't have them defined.
+  #
+  # See #instance_assume.
 
   def instance_assume!(obj, *vars)
     if vars.empty?
@@ -135,8 +136,10 @@ module Kernel
   #   @b   #=> 2
   #
   #--
-  # TODO Make a little more flexiable to allow any hash-like object.
-  # TODO Should is also accept class variables? (eg. @@a)
+  # TODO: Make a little more flexiable to allow any hash-like object.
+  # TODO: Should is also accept class variables? (eg. @@a)
+  # TODO: Should instance_assign be named instance_variable_assign?
+  #       Likewise for instance_assume. Is there a better term than 'assume'?
   #++
 
   def instance_assign(*args)
@@ -171,75 +174,3 @@ module Kernel
   # For backward compatability (DEPRECATED).
   alias :assign_with :instance_assign
 end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TestKernelInstance < Test::Unit::TestCase
-
-    def test_instance_class
-      o = Object.new
-      assert_equal( (class << o; self; end), o.instance_class )
-    end
-
-    def test_instance_assign
-      ahash = { "z"=>0, "@a"=>1, "@b"=>2 } #, "@@a"=>3 }
-      instance_assign( ahash )
-      assert_equal( 0, @z )
-      assert_equal( 1, @a )
-      assert_equal( 2, @b )
-      #assert_equal( 3, @@a )
-    end
-
-  end
-
-  class TestInstanceEvalWithArgs < Test::Unit::TestCase
-
-    class Dummy
-      def f
-        :dummy_value
-      end
-    end
-
-    def test_instance_exec
-      # Create a block that returns the value of an argument
-      # and a value of a method call to +self+.
-      block = lambda { |a| [a, f] }
-      assert_equal [:arg_value, :dummy_value],
-        Dummy.new.instance_exec(:arg_value, &block)
-    end
-
-    def test_instance_exec_with_frozen_obj
-      block = lambda { |a| [a, f] }
-      obj = Dummy.new
-      obj.freeze
-      assert_equal [:arg_value, :dummy_value], obj.instance_exec(:arg_value, &block)
-    end
-
-    def test_instance_exec_nested
-      i = 0
-      obj = Dummy.new
-      block = lambda do |arg|
-        [arg] + instance_exec(1){|a| [f, a] }
-      end
-      assert_equal([:arg_value, :dummy_value, 1], obj.instance_exec(:arg_value, &block))
-    end
-
-    def test_instance_exec_with_immediate_value
-      obj = 1
-      block = lambda { |a| [a,self] }
-      assert_equal(["A", 1], obj.instance_exec("A", &block))
-    end
-
-  end
-
-=end

data/lib/core/facets/kernel/metaid.rb

@@ -1,16 +1,3 @@
-# TITLE:
-#
-#   Metaid
-#
-# SUMMARY:
-#
-#   Meta programming methods, for accessing
-#   object singleton class.
-#
-# AUTHORS:
-#
-#   CREDIT WhyTheLuckyStiff
-
 require 'facets/functor'
 
 module Kernel
@@ -24,6 +11,8 @@ module Kernel
   #
   #   X.a = 1
   #   X.a #=> 1
+  #
+  #  CREDIT: Trans
 
   def meta
     @_meta_functor ||= Functor.new do |op,*args|
@@ -32,6 +21,12 @@ module Kernel
   end
 
   # Alias a method defined in the metaclass (ie. singleton class).
+  #
+  #   def X.y?; "y?" ; end
+  #   X.meta_alias "ynot?", "y?"
+  #   X.ynot?  #=> y?
+  #
+  #   CREDIT: Trans
 
   def meta_alias(*args)
     meta_class do
@@ -39,17 +34,26 @@ module Kernel
     end
   end
 
-  # Evaluate code in a metaclass.
+  # Evaluate code in a metaclass. This is equivalent to
+  # 'meta_class.instance_eval'.
+  #
+  #   CREDIT: WhyTheLuckyStiff
 
-  def meta_eval( str=nil, &blk )
+  def meta_eval(str=nil, &blk)
     if str
-      meta_class.instance_eval( str )
+      meta_class.instance_eval(str)
     else
-      meta_class.instance_eval( &blk )
+      meta_class.instance_eval(&blk)
     end
   end
 
-  # Add method to a meta-class.
+  # Add method to a meta-class --i.e. a singleton method.
+  #
+  #   class X; end
+  #   X.meta_def(:x){"x"}
+  #   X.x  #=> "x"
+  #
+  #   CREDIT: WhyTheLuckyStiff
 
   def meta_def( name, &block )
     meta_class do
@@ -57,12 +61,6 @@ module Kernel
     end
   end
 
-  # Defines an instance method within a class.
-
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end
-
   # Easy access to an object's "special" class,
   # otherwise known as it's metaclass or singleton class.
 
@@ -85,6 +83,8 @@ module Kernel
   #
   #                       -- why the lucky stiff
   #
+  #   CREDIT: WhyTheLuckyStiff
+
   def eigenclass
     (class << self; self; end)
   end
@@ -112,6 +112,8 @@ module Kernel
   # known as the object's metaclass or singleton class.
   #
   # Yes, another one.
+  #
+  #   CREDIT: Trans
 
   def qua_class(&block)
     if block_given?
@@ -124,6 +126,8 @@ module Kernel
   # Universal assignment. This is a meta-programming
   # method, which allows you to assign any type of variable.
   #
+  #   CREDIT: Trans
+
   def __assign__(name, value)
     k = name.to_s
     v = value
@@ -143,56 +147,14 @@ module Kernel
 end
 
 
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
+class Module
 
-  require 'test/unit'
-
-  class TCKernel < Test::Unit::TestCase
-
-    def test_metaclass
-      o = Object.new
-      assert_equal( (class << o; self; end), o.metaclass )
-    end
-
-   def test_meta_class
-      o = Object.new
-      assert_equal( (class << o; self; end), o.meta_class )
-    end
-
-    def test_singleton
-      o = Object.new
-      assert_equal( (class << o; self; end), o.singleton )
-    end
-
-    #def test_singleton_eval
-    #  assert_nothing_raised do
-    #    o.singleton_class_eval{ @@a = "test" }
-    #  end
-    #end
-
-    #def test_singleton_method
-    #  assert_nothing_raised do
-    #    o.define_singleton_method(:testing){ |x| x + 1 }
-    #  end
-    #  assert_equal(2, o.testing(1) )
-    #end
-
-    def test_singleton_Class
-      o = Object.new
-      assert_equal( (class << o; self; end), o.singleton_class )
-    end
-
-    def test_qua_class
-      o = Object.new
-      assert_equal( (class << o; self; end), o.qua_class )
-    end
+  # Defines an instance method within a class.
+  #
+  #   CREDIT: WhyTheLuckyStiff
 
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
   end
 
-=end
+end