facets 1.8.54 → 2.0.0

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

@@ -0,0 +1,60 @@
+# 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,
+  # and, unlike +const_get+, can handle module hierarchy.
+  #
+  #   constant("Fixnum")                  # -> Fixnum
+  #   constant(:Fixnum)                   # -> Fixnum
+  #
+  #   constant("Process::Sys")            # -> Process::Sys
+  #   constant("Regexp::MULTILINE")       # -> 4
+  #
+  #   require 'test/unit'
+  #   Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
+  #   Test.constant("::Test::Unit")       # -> Test::Unit
+  #
+  def constant(const)
+    const = const.to_s.dup
+    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+  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

@@ -0,0 +1,111 @@
+# 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.
+  # This is also commonly called a deep_copy.
+  #
+  #   "ABC".copy  #=> "ABC"
+  #
+  def copy
+    Marshal::load(Marshal::dump(self))
+  end
+
+  alias 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.
+  # Moreover deep_clone checks if the object is already cloned to prevent endless recursion.
+  #
+  #   obj = []
+  #   a = [ true, false, obj ]
+  #   b = a.deep_clone
+  #   obj.push( 'foo' )
+  #   p obj   # >> [ 'foo' ]
+  #   p b[2]  # >> []
+
+  def deep_clone( obj=self, cloned={} )
+    if cloned.has_key?( obj.object_id )
+      return cloned[obj.object_id]
+    else
+      begin
+        cl = obj.clone
+      rescue Exception
+        # unclonnable (TrueClass, Fixnum, ...)
+        cloned[obj.object_id] = obj
+        return obj
+      else
+        cloned[obj.object_id] = cl
+        cloned[cl.object_id] = cl
+        if cl.is_a?( Hash )
+          cl.clone.each { |k,v|
+            cl[k] = deep_clone( v, cloned )
+          }
+        elsif cl.is_a?( Array )
+          cl.collect! { |v|
+                  deep_clone( v, cloned )
+          }
+        end
+        cl.instance_variables.each do |var|
+          v = cl.instance_eval( var )
+          v_cl = deep_clone( v, cloned )
+          cl.instance_eval( "#{var} = v_cl" )
+        end
+        return cl
+      end
+    end
+  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

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

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

@@ -0,0 +1,245 @@
+# 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'
+
+#
+module Kernel
+
+  # Shadow method for instance_variable_get.
+  alias :__get__ :instance_variable_get
+
+  # Shadow method for instance_variable_set.
+  alias :__set__ :instance_variable_set
+
+  # Private send. Why isn't #send called instance_send in the first place?
+  alias :instance_send :send
+
+  # Easy access to an object qua class, otherwise known
+  # as the object's metaclass or singleton class. This
+  # implemnetation alwasy returns the class, even if a
+  # block is provided to eval against it.
+  #
+  #     It is what it is.
+  #
+  #               -- 7rans0noma
+  #
+  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.
+  def instance_values
+    instance_variables.inject({}) do |values, name|
+    values[name[1..-1]] = instance_variable_get(name)
+      values
+    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
+  #     attr_accessor :d
+  #     def initialize( a, b, c, d)
+  #       @a = a
+  #       @b = b
+  #       @c = c
+  #       @d = d
+  #     end
+  #   end
+  #   o1 = O.new(1,2,3,4)
+  #   o2 = O.new(0,0,0,0)
+  #
+  #   o2.instance_assume( o1, '@a', '@b', '@c', '@d' )
+  #   o2.instance_eval{ @a }  #=> 1
+  #   o2.instance_eval{ @b }  #=> 2
+  #   o2.instance_eval{ @c }  #=> 3
+  #   o2.instance_eval{ @d }  #=> 4
+
+  def instance_assume(obj, *vars)
+    if vars.empty?
+      vars = instance_vars | obj.instance_variables
+    else
+      vars = vars.collect do |k|
+        var.to_s.slice(0,1) == '@' ? var : "@#{var}"
+      end
+      vars = vars | instance_variables | obj.instance_variables
+    end
+    vars.each do |var|
+      instance_variable_set(var, obj.instance_variable_get(var))
+    end
+    return self  # ???
+  end
+
+  # For backward compatability (DEPRECATED).
+  alias :assign_from :instance_assume
+
+  # As with #instance_assume, but forces the setting of the object's
+  # instance varaibles even if the recieve doesn't have them defined.
+
+  def instance_assume!(obj, *vars)
+    if vars.empty?
+      vars = obj.instance_variables
+    else
+      vars = vars.collect do |k|
+        var.to_s.slice(0,1) == '@' ? var : "@#{var}"
+      end
+      vars = vars | obj.instance_variables
+    end
+    vars.each do |var|
+      instance_variable_set(var, obj.instance_variable_get(var))
+    end
+    return self  # ???
+  end
+
+  # Shadow method for instance_assume.
+  alias :__assume__ :instance_assume if defined?(instance_assume)
+
+  # Set instance variables using a hash (or assoc array).
+  #
+  #   instance_assign('@a'=>1, '@b'=>2)
+  #   @a   #=> 1
+  #   @b   #=> 2
+  #
+  #--
+  # TODO Make a little more flexiable to allow any hash-like object.
+  # TODO Should is also accept class variables? (eg. @@a)
+  #++
+
+  def instance_assign(*args)
+    harg = args.last.is_a?(Hash) ? args.pop : {}
+
+    unless args.empty?
+      # if not assoc array, eg. [ [], [], ... ]
+      # preserves order of opertation
+      unless args[0].is_a?(Array)
+        i = 0; a = []
+        while i < args.size
+          a << [ args[i], args[i+1] ]
+          i += 2
+        end
+        args = a
+      end
+    end
+
+    args.each do |k,v|
+      k = "@#{k}" if k !~ /^@/
+      instance_variable_set(k, v)
+    end
+
+    harg.each do |k,v|
+      k = "@#{k}" if k !~ /^@/
+      instance_variable_set(k, v)
+    end
+
+    return self
+  end
+
+  # 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

@@ -0,0 +1,198 @@
+# TITLE:
+#
+#   Metaid
+#
+# SUMMARY:
+#
+#   Meta programming methods, for accessing
+#   object singleton class.
+#
+# AUTHORS:
+#
+#   CREDIT WhyTheLuckyStiff
+
+require 'facets/functor'
+
+module Kernel
+
+  # Provides access to an object's metaclass (ie. singleton)
+  # by-passsing access provisions. So for example:
+  #
+  #   class X
+  #     meta.attr_accesser :a
+  #   end
+  #
+  #   X.a = 1
+  #   X.a #=> 1
+
+  def meta
+    @_meta_functor ||= Functor.new do |op,*args|
+      (class << self; self; end).send(op,*args)
+    end
+  end
+
+  # Alias a method defined in the metaclass (ie. singleton class).
+
+  def meta_alias(*args)
+    meta_class do
+      alias_method(*args)
+    end
+  end
+
+  # Evaluate code in a metaclass.
+
+  def meta_eval( str=nil, &blk )
+    if str
+      meta_class.instance_eval( str )
+    else
+      meta_class.instance_eval( &blk )
+    end
+  end
+
+  # Add method to a meta-class.
+
+  def meta_def( name, &block )
+    meta_class do
+      define_method( name, &block )
+    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.
+
+  def meta_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+  alias_method :metaclass, :meta_class
+
+  # During this trying time when no one can get their
+  # techie catchwords to stick to the refrigerator no
+  # matter how hard they slap it # with the enchanted
+  # magnetic spatula, it’s good to know that the
+  # contrived phrases really do fly, graceful and
+  # unclasped and bearing north toward chilled shrimp.
+  # I know what my Hallowe’en pumpkin is going to say.
+  #
+  #                       -- why the lucky stiff
+  #
+  def eigenclass
+    (class << self; self; end)
+  end
+
+  # Access to an object's "special" class, otherwise
+  # known as it's eigenclass or metaclass, etc.
+  #
+  # One day these names must be reconciled!
+
+  def singleton
+    (class << self; self; end)
+  end
+
+  # Access to an object's "special" class, otherwise
+  # known as it's eigenclass or metaclass or own, etc.
+  #
+  # One day these names must be reconciled!
+
+  def singleton_class
+    (class << self; self; end)
+  end
+  alias_method :__singleton_class__, :singleton_class
+
+  # Easy access to an object qua class, otherwise
+  # known as the object's metaclass or singleton class.
+  #
+  # Yes, another one.
+
+  def qua_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+  # Universal assignment. This is a meta-programming
+  # method, which allows you to assign any type of variable.
+  #
+  def __assign__(name, value)
+    k = name.to_s
+    v = value
+    /^([@$]{0,2})/ =~ k
+    case $1
+    when '$', '@@'
+      instance_eval %Q{ #{k} = v }
+    when '@'
+      instance_variable_set( k, v )
+    else
+      return __send__( "#{k}=", v ) if respond_to?("#{k}=")
+      # No accessor? What to do? Assume instance var, or error? ...
+      self.instance_variable_set( "@#{k}", v )
+    end
+    return value
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  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
+
+  end
+
+=end