facets 0.6.3

data/lib/facet/object/__class__.rb

@@ -0,0 +1,17 @@
+class Object
+  # Defines core method __class__ as an alias of class.
+  # This allows you to use #class as your own method, without
+  # loosing the ability to determine the object's class.
+  #
+  #   require 'facet/object/__class__'
+  #
+  alias_method( :__class__, :class )
+
+  # Defines object_classas an alias of class.
+  # This is an alternative to __class__, akin to
+  # #object_id.
+  #
+  #   require 'facet/object/__class__'
+  #
+  alias_method( :object_class, :class )
+end

data/lib/facet/object/assign_with.rb

@@ -0,0 +1,80 @@
+class Object
+  
+  # Set setter methods and/or vars using a hash (or assoc array).
+  # #assign_with is a meta-programming method, which allows you to 
+  # use a hash to do any kind of variable assignment and/or setting:
+  #
+  # For example, assuming that there is an accessor defined as <tt>d</tt>:
+  #
+  #   require 'facet/object/assign_with'
+  #
+  #   assign_with { '@a'=>1, '@@b'=>2, '$c'=>3, 'd'=>4 }
+  #   @a   #=> 1
+  #   @@b  #=> 2
+  #   $c   #=> 3
+  #   d    #=> 4
+  #
+  # Note that while the global variable is strictly unnecessary,
+  # it works for completeness sake.
+  def assign_with(*args)
+    if args[0].is_a?(Hash) #or args[0].is_a?(Array)
+      iv_val_pairs = args[0]
+    else
+      raise ArgumentError, "Hash required for assigning multiple variables" if args.length > 2
+      iv_val_pairs = { args[0] => args[1] }
+    end
+    iv_val_pairs.each_pair do |k,v|
+      if k.to_s.slice(0,2) == '@@'
+        self.instance_eval %Q{ #{k} = v }
+      else
+        case k.to_s.slice(0,1)
+        when '$'
+          self.instance_eval %Q{ #{k} = v }
+        when '@'
+          self.instance_variable_set( k, v )
+          @__atttributes__ |= k
+        else
+          self.instance_variable_set( "@#{k}", v )
+          @__atttributes__ |= "@#{k}"
+          #self.send( "#{k}=", v ) #if respond_to?("#{k}=")
+        end
+      end
+    end
+  end
+  
+  # Set setter methods and/or instance vars using a hash from another object.
+  #
+  #   require 'facet/object/assign_with'
+  #
+  #   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.assign_from { o1, '@a', '@@b', '$c', 'd' }
+  #   o2.instance_eval{ @a }   #=> 1
+  #   o2.instance_eval{ @@b }  #=> 2
+  #   o2.instance_eval{ $c }   #=> 3
+  #   02.d                     #=> 4
+  #
+  # See also #assign_with.
+  def assign_from(obj, *fields)
+    fields.each do |k|
+      var = k.to_s
+      var = var.slice(0,1) == '@' ? var : "@#{var}"
+      self.instance_variable_set( var, obj.instance_variable_get(var) ) if obj.instance_variables.include?(var)
+      @__atttributes__ |= var
+#       else
+#         self.instance_variable_set( k, obj.instance_variable_get(k) ) if obj.instance_variables.include?(k)
+#         #self.send( "#{k}=", obj.send("#{k}") ) if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+#       end
+    end
+  end
+end

data/lib/facet/object/bool?.rb

@@ -0,0 +1,49 @@
+class Object
+  # Returns true is an object is class TrueClass
+  # or FalseClass, otherwise false.
+  #
+  #   require 'facet/object/bool?'
+  #
+  #   true.bool?   #=> true
+  #   false.bool?  #=> true
+  #   nil.bool?    #=> false
+  #
+  #--
+  # As suggested by Ara T. Howard
+  #++
+  def bool?
+    (true == self or false == self)
+  end
+  
+  # Returns true is an object is class TrueClass,
+  # otherwise false.
+  #
+  #   require 'facet/object/bool?'
+  #
+  #   true.true?   #=> true
+  #   false.true?  #=> false
+  #   nil.true?    #=> false
+  #
+  #--
+  # As suggested by Mohammad Khan
+  #++
+  def true?
+    (true == self)
+  end
+  
+  # Returns true is an object is class FalseClass,
+  # otherwise false.
+  #
+  #   require 'facet/object/bool?'
+  #
+  #   true.false?   #=> false
+  #   false.false?  #=> true
+  #   nil.false?    #=> false
+  #
+  #--
+  # As suggested by Mohammad Khan
+  #++
+  def false?
+    (false == self)
+  end
+end

data/lib/facet/object/constant.rb

@@ -0,0 +1,22 @@
+class Object
+  # This is similar to +Module#const_get+ but is accessible at all levels,
+  # and, unlike +const_get+, can handle module hierarchy.
+  #
+  #   require 'facet/object/constant'
+  #
+  #   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  

data/lib/facet/object/copy.rb

@@ -0,0 +1,13 @@
+class Object
+  # Anything that can be marshaled can be copied in totality.
+  # This is also commonly called a deep_copy.
+  #
+  #   require 'facet/object/copy'
+  #
+  #   "ABC".copy  #=> "ABC"
+  #
+  def copy
+    Marshal::load(Marshal::dump(self))
+  end
+  alias_method( :deep_copy, :copy )
+end  

data/lib/facet/object/in?.rb

@@ -0,0 +1,12 @@
+class Object
+  # Is self included in other?
+  #
+  #   require 'facet/object/in?'
+  #
+  #   5.in?(0..10)       #=> true
+  #   5.in?([0,1,2,3])   #=> false
+  #
+  def in?(other)
+    other.include?(self)
+  end 
+end

data/lib/facet/object/new.rb

@@ -0,0 +1,32 @@
+class Object
+  # Synonymous with #clone, this is an interesting 
+  # method in that it promotes prototype-based Ruby.
+  # Now Classes aren't the only things that respond to #new.
+  #
+  #   require 'facet/object/new'
+  #
+  #   "ABC".new  => "ABC"
+  #
+  def new
+    self.clone
+  end
+end
+
+
+=begin
+# --- dev test ---
+
+if $0 == __FILE__
+
+  s = String.new
+  s.replace("Testing")
+  p a=s,b=s.__id__
+  
+  g = s.new
+  p c=g,d=g.__id__
+  
+  #assert_equal(a,c)
+  #assert_not_equal(b,d)
+  
+end
+=end

data/lib/facet/object/object_hexid.rb

@@ -0,0 +1,12 @@
+class Object
+  # Returns the object id as a string in hexideciaml,
+  # which is how Ruby reports them with inspect.
+  #
+  #   require 'facet/object/object_hexid'
+  #
+  #   "ABC".object_hexid  #=> "0x402d359c"
+  #
+  def object_hexid
+    return "0x#{'%x'%(2*self.__id__)}"
+  end
+end

data/lib/facet/object/set_with.rb

@@ -0,0 +1,29 @@
+class Object
+  
+  # Set setter methods and/or vars using a hash (or assoc array).
+  #
+  #   require 'facet/object/set_with'
+  #
+  def set_with(*args)
+    if args.first.is_a?(Hash)  #or args[0].is_a?(Array)
+      iv_val_paris = args.first
+    else
+      raise ArgumentError, "Hash required for assigning multiple variables" if args.length > 2
+      iv_val_paris = { args[0] => args[1] }
+    end
+    iv_val_paris.each_pair do |k,v|
+      self.send( "#{k}=", v ) #if respond_to?("#{k}=")
+    end
+  end
+  
+  # Set setter methods and/or instance vars using a hash from another object.
+  #
+  #   require 'facet/object/set_with'
+  #
+  def set_from(obj, *fields)
+    fields.each do |k|
+      self.send( "#{k}=", obj.send("#{k}") ) #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+    end
+  end
+  
+end

data/lib/facet/object/special_class.rb

@@ -0,0 +1,45 @@
+class Object
+
+  # Access to an object's special singleton class.
+  #
+  #   require 'facet/object/special_class'
+  #
+  def special_class
+    (class << self; self; end)
+  end
+
+  # Alias for #special_class.
+  #
+  #   require 'facet/object/special_class'
+  #
+  alias_method :singleton_class, :special_class
+
+  # Special singleton class eval.
+  #
+  #   require 'facet/object/special_class'
+  #
+  def special_class_eval(&block)
+    special_class.class_eval(&block)
+  end
+
+  # Alias for #special_class_eval.
+  #
+  #   require 'facet/object/special_class'
+  #
+  alias_method :singleton_class_eval, :special_class_eval
+
+  # Special singleton class define method.
+  #
+  #   require 'facet/object/special_class'
+  #
+  def define_special_method(meth, &block)
+    special_class_eval{ define_method(meth, &block) }
+  end
+  
+  # Alias for #define_special_method.
+  #
+  #   require 'facet/object/special_class'
+  #
+  alias_method :define_singleton_method, :define_special_method
+  
+end 

data/lib/facet/object/supers.rb

@@ -0,0 +1,38 @@
+begin
+  require 'carat/functor'
+rescue
+  class Functor
+    def initialize(&func) ; @func = func ; end
+    def method_missing(op, *args) ; @func.call(op, *args) ; end
+  end
+end
+class Object
+  # Returns method of a parent class bound to self.
+  #
+  #   require 'facet/object/supers'
+  #
+  def super_method(klass, meth)
+    raise ArgumentError if ! self.class.ancestors.include?(klass)
+    klass.instance_method(meth).bind(self) #.call(*args)
+  end
+  
+  # Call parent class/module methods once bound to self.
+  #
+  #   require 'facet/object/supers'
+  #
+  def super_send(klass, meth, *args, &blk)
+    raise ArgumentError if ! self.class.ancestors.include?(klass)
+    klass.instance_method(meth).bind(self).call(*args, &blk)
+  end
+  
+  # Returns a Functor that allows one to call any parent method directly.
+  #
+  #   require 'facet/object/supers'
+  #
+  def supers(klass=self.class.superclass)
+    raise ArgumentError if ! self.class.ancestors.include?(klass)
+    Functor.new do |meth, *args|  # &blk|
+      klass.instance_method(meth).bind(self).call(*args) # ,&blk)
+    end
+  end
+end

data/lib/facet/object/to_b.rb

@@ -0,0 +1,15 @@
+require 'facet/object/to_bool'
+class Object
+  # Alias for #to_bool. This one other classes
+  # may redefine to suit their needs.
+  #
+  #   require 'facet/object/to_b'
+  #
+  #   "abc".to_b   #=> true
+  #   true.to_b    #=> true
+  #   false.to_b   #=> false
+  #   nil.to_b     #=> false
+  #  
+  alias_method( :to_b, :to_bool )
+end
+

data/lib/facet/object/to_bool.rb

@@ -0,0 +1,14 @@
+class Object
+  # Boolean conversion for not being nil or false.
+  #
+  #   require 'facet/object/to_b'
+  #
+  #   "abc".to_bool   #=> true
+  #   true.to_bool    #=> true
+  #   false.to_bool   #=> false
+  #   nil.to_bool     #=> false
+  #
+  def to_bool
+    self ? true : false
+  end
+end

data/lib/facet/object/with_accessor.rb

@@ -0,0 +1,50 @@
+class Object
+  # Takes a hash and creates (singleton) attr_readers for each key.
+  #
+  #   require 'facet/object/with_accessor'
+  #
+  #   with_reader { :x => 1, :y => 2 }
+  #   @x       #=> 1
+  #   @y       #=> 2
+  #   self.x   #=> 1
+  #   self.y   #=> 2
+  #
+  def with_reader(h)
+    (class << self ; self ; end).send( :attr_reader, *h.keys )
+    h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Takes a hash and creates (singleton) attr_writers for each key.
+  #
+  #   require 'facet/object/with_accessor'
+  #
+  #   with_writer { :x => 1, :y => 2 }
+  #   @x           #=> 1
+  #   @y           #=> 2
+  #   self.x = 3
+  #   self.y = 4
+  #   @x           #=> 3
+  #   @y           #=> 4
+  #
+  def with_writer(h)
+    (class << self ; self ; end).send( :attr_writer, *h.keys )
+    h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Takes a hash and creates (singleton) attr_accessors for each key .
+  #
+  #   require 'facet/object/with_accessor'
+  #
+  #   with_accessor { :x => 1, :y => 2 }
+  #   @x           #=> 1
+  #   @y           #=> 2
+  #   self.x = 3
+  #   self.y = 4
+  #   self.x       #=> 3
+  #   self.y       #=> 4
+  #
+  def with_accessor(h)
+    (class << self ; self ; end).send( :attr_accessor, *h.keys )
+    h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+end