facets 2.8.2 → 2.8.3

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

@@ -0,0 +1,45 @@
+module Kernel
+
+  # Set attribute writers using like readers
+  # from another object.
+  #
+  #   class X
+  #     attr_accessor :a, :b
+  #     def initialize( a, b )
+  #        @a,@b = a,b
+  #     end
+  #   end
+  #
+  #   obj1 = X.new(1, 2)
+  #   obj2 = X.new
+  #
+  #   obj2.assign_from(obj1)
+  #
+  #   obj2.a  #=> 1
+  #   obj2.b  #=> 2
+  #
+  # TODO: Should this be called #set_from ?
+
+  def assign_from(obj, *fields)
+    unless fields.empty?
+      fields.each do |k|
+        send( "#{k}=", obj.send("#{k}") )  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+      end
+    else
+      setters = methods.collect { |m| m =~ /=$/ }
+      setters.each do |setter|
+        getter = setter.chomp('=')
+        if obj.respond_to?(getter)
+          send( setter, obj.send(getter) )
+          fields < getter
+        end
+      end
+    end
+    fields
+  end
+
+  # Original name for #assign_from.
+  alias_method :set_from, :assign_from
+
+end
+

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

@@ -0,0 +1,63 @@
+module Kernel
+  # Override this in a child class if it cannot be dup'ed.
+  #
+  # CREDIT: Dan Kubb (extlib)
+  def dup!
+    dup
+  end
+
+  # Original name for dup! as defined by extlib.
+  # This will eventually be deprecated. Use #dup! instead.
+  def try_dup
+    dup!
+  end
+end
+
+class TrueClass
+  # Since TrueClass is immutable it cannot be duplicated.
+  # For this reason #dup! returns +self+.
+  def dup!
+    self
+  end
+end
+
+class FalseClass
+  # Since FalseClass is immutable it cannot be duplicated.
+  # For this reason #dup! returns +self+.
+  def dup!
+    self
+  end
+end
+
+class NilClass
+  # Since NilClass is immutable it cannot be duplicated.
+  # For this reason #dup! returns +self+.
+  def dup!
+    self
+  end
+end
+
+class Numeric
+  # Since Numeric is immutable it cannot be duplicated.
+  # For this reason #dup! returns +self+.
+  def dup!
+    self
+  end
+end
+
+class Symbol
+  # Since Symbol is immutable it cannot be duplicated.
+  # For this reason #dup! returns +self+.
+  def dup!
+    self
+  end
+end
+
+#class Module
+#  # Since Module is immutable it cannot be duplicated.
+#  # For this reason #dup! returns +self+.
+#  def dup!
+#    self
+#  end
+#end
+

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

@@ -0,0 +1,156 @@
+module Kernel
+  INSTANCES = {}
+
+  # Returns an instance of Instance for +self+,
+  # which allows convenient access to an object's
+  # internals.
+
+  def instance
+    INSTANCES[self] ||= Instance.new(self)
+  end
+
+end
+
+# = Instance Class
+#
+#   class Friend
+#     attr_accessor :name, :age, :phone
+#     def initialize(name, age, phone)
+#       @name, @age, @phone = name, age, phone
+#     end
+#   end
+#
+#   f1 = Friend.new("John", 30, "555-1212")
+#   p f1.instance
+#   f1.instance.update({:name=>'Jerry'})
+#   p f1.instance
+#
+class Instance
+
+  include Enumerable
+
+  #
+  def initialize(delegate)
+    @delegate = delegate
+  end
+
+  #
+  def instance_delegate
+    @delegate
+  end
+
+  #
+  def each
+    @delegate.instance_variables.each do |name|
+      yield(name[1..-1].to_sym, @delegate.instance_variable_get(name))
+    end
+  end
+
+  # Return instance variables with values as a hash.
+  #
+  #   class X
+  #     def initialize(a,b)
+  #       @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   x = X.new(1,2)
+  #
+  #   x.instance.to_h  #=> { :a=>1, :b=>2 }
+  #
+  def to_h(at=false)
+    h = {}
+    if at
+      @delegate.instance_variables.each do |name|
+        h[name] = @delegate.instance_variable_get(name)
+      end
+    else
+      each do |key, value|
+        h[key] = value
+      end
+    end
+    h
+  end
+
+  # TODO: Not sure if this should be used.
+  alias_method :to_hash, :to_h
+
+  #
+  def [](name)
+    name = atize(name)
+    @delegate.instance_variable_get(name)
+  end
+
+  #
+  def []=(name, value)
+    name = atize(name)
+    @delegate.instance_variable_set(name,value)
+  end
+
+  #
+  def <<(pair)
+    name, value = *pair
+    name = atize(name)
+    @delegate.instance_variable_set(name, value)
+  end
+
+  # Set instance variables given a +hash+.
+  #
+  #   instance.update('@a'=>1, '@b'=>2)
+  #   @a   #=> 1
+  #   @b   #=> 2
+  #
+  # Also, +@+ sign is not neccessary.
+  #
+  #   instance.update(:a=>1, :b=>2)
+  #   @a   #=> 1
+  #   @b   #=> 2
+  #
+  def update(hash)
+    hash.each do |pair|
+      self << pair
+    end
+  end
+
+  # A hold-over from the the old #instance_assign method.
+  alias_method :assign, :update
+
+  # Same as #instance_variables.
+  def variables
+    @delegate.instance_variables
+  end
+
+  # Instance vairable names as symbols.
+  def keys
+    @delegate.instance_variables.collect do |name|
+      name[1..-1].to_sym
+    end
+  end
+
+  # Instance variable names as strings.
+  def names
+    @delegate.instance_variables.collect do |name|
+      name[1..-1]
+    end
+  end
+
+  # Instance variable values.
+  def values
+    @delegate.instance_variables.collect do |name|
+      @delegate.instance_variable_get(name)
+    end
+  end
+
+  # Instance evaluation.
+  def eval(*a,&b)
+    @delegate.instance_eval(*a,&b)
+  end
+
+  private
+
+    def atize(name)
+      name.to_s !~ /^@/ ? "@#{name}" : name
+    end
+
+end
+

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

@@ -1,33 +1,12 @@
 module Kernel
 
-  # 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   #=> { "a"=>1, "b"=>2 }
-  #
-  # WARNING: #instance_values will be deprecated. Use instance_vars.to_hash instead.
-
-  def instance_values
-    instance_variables.inject({}) do |values, name|
-      values[name[1..-1]] = instance_variable_get(name)
-      values
-    end
-  end
-
   # Set instance variables using a hash.
   #
   #   instance_assign('@a'=>1, '@b'=>2)
   #   @a   #=> 1
   #   @b   #=> 2
   #
-  # WARNING: #instance_assign will be deprecated. Use instance_vars.update instead.
+  # DEPRECATE: Use instance.update instead of #instance_assign.
 
   def instance_assign(hash)
     hash.each do |k,v|

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

@@ -1,3 +1,5 @@
+require 'facets/kernel/meta_class'
+
 module Kernel
 
   # Add method to a meta-class --i.e. a singleton method.
@@ -14,5 +16,7 @@ module Kernel
     end
   end
 
+  alias_method :metadef, :meta_def
+
 end
 

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

@@ -1,75 +1,2 @@
-module Kernel
-
-  # Assign via accessor methods using a hash, associative
-  # array or block.
-  #
-  #   object.populate( :a => 1, :b => 2 )
-  #   object.populate( :a, 1, :b, 2 )
-  #   object.populate( [:a, 1], [:b, 2] )
-  #   object.populate( *[[:a, 1], [:b, 2]] )
-  #   object.populate{ |s| s.a = 1; s.b = 2 }
-  #
-  # These are all the same as doing:
-  #
-  #   object.a = 1
-  #   object.b = 2
-  #
-  # Using an associative array instead of hash guarentees
-  # order of assignemnt.
-  #
-  # Using a hash or array will not raise an error if the
-  # accessor does not exits -- it will simply be skipped.
-  #
-  # (See also: instance_vars.update, which sets instance variables directly, bypassing accessor method.)
-  #
-  # TODO: Better name, #set_with ?
-
-  def populate(data=nil) #:yield:
-    if data
-      data.each do |k,v|
-        send("#{k}=", v) if respond_to?("#{k}=")
-      end
-    end
-    yield(self) if block_given?
-    self
-  end
-
-  # Set setter methods using a another object.
-  #
-  #   class X
-  #     attr_accessor :a, :b
-  #     def initialize( a, b )
-  #        @a,@b = a,b
-  #     end
-  #   end
-  #
-  #   obj1 = X.new( 1, 2 )
-  #   obj2 = X.new
-  #
-  #   obj2.set_from(obj1)
-  #
-  #   obj2.a  #=> 1
-  #   obj2.b  #=> 2
-  #
-  # TODO: populate_from(obj) ?
-
-  def set_from(obj, *fields)
-    unless fields.empty?
-      fields.each do |k|
-        send( "#{k}=", obj.send("#{k}") )  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
-      end
-    else
-      setters = methods.collect { |m| m =~ /=$/ }
-      setters.each do |setter|
-        getter = setter.chomp('=')
-        if obj.respond_to?(getter)
-          send( setter, obj.send(getter) )
-          fields < getter
-        end
-      end
-    end
-    fields
-  end
-
-end
+require 'facets/kernel/assign'
 

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

@@ -0,0 +1,2 @@
+require 'facets/kernel/assign_from'
+

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

@@ -0,0 +1 @@
+require 'facets/kernel/dup'

data/lib/core/facets/module/set.rb

@@ -0,0 +1,36 @@
+class Module
+
+  unless method_defined?(:set)
+
+    # Sets an option to the given value. If the value is a proc,
+    # the proc will be called every time the option is accessed.
+    #
+    # CREDIT: ? (Sinatra)
+
+    def set(option, value=self, &block)
+      raise ArgumentError if block && value != self
+      value = block if block
+      if value.kind_of?(Proc)
+        if value.arity == 1
+          yield self
+        else
+          (class << self; self; end).module_eval do
+            define_method(option, &value)
+            define_method("#{option}?"){ !!__send__(option) }
+            define_method("#{option}="){ |val| set(option, Proc.new{val}) }
+          end
+        end
+      elsif value == self
+        option.each{ |k,v| set(k, v) }
+      elsif respond_to?("#{option}=")
+        __send__("#{option}=", value)
+      else
+        set(option, Proc.new{value})
+      end
+      self
+    end
+
+  end
+
+end
+

data/lib/core/facets/objectspace/reflect.rb

@@ -0,0 +1,45 @@
+require 'facets/functor'
+
+class << ObjectSpace
+
+  # Reflection ensures that information about an object
+  # is actual according to Ruby's Kernel definitions, just
+  # in case such methods have been overridden.
+  #
+  #  ObjectSpace.reflect(obj).id
+  #
+  #--
+  # There is also a global short-cut for this method to ease
+  # meta-programming with it.
+  #
+  #   $ref[obj].id
+  #++
+  #
+  # Typically theis method will be used to gather the object's
+  # id, as in the example given, or it's class, but any Kernel
+  # method can be used.
+  #
+  # Care should be taken in utilizing this technique. In most
+  # cases it is not needed, but in certain cases is useful
+  # for improving the robustness of meta-programming solutions.
+  #
+  # Note that this is also equivalent to using +as(Kernel)+:
+  #
+  #   obj.as(Kernel).id
+  #
+  # But obviously, in this case there is the risk that #as has
+  # be overridden too.
+  #
+  def reflect(obj)
+    Functor.new do |meth, *a, &b|
+      Kernel.instance_method(meth).bind(obj).call(*a, &b)
+    end
+  end
+
+end
+
+# TODO: Consider this "Shorcut for +ObjectSpace.reflect+."
+#$ref = lambda do |obj|
+#  ObjectSpace.reflect(obj)
+#end
+