facets 2.9.1 → 2.9.2

data/work/defunct/core/facets/hash/op_div.rb

@@ -0,0 +1,11 @@
+class Hash
+
+  # Use division operator as a fetch notation.
+  #
+  #   h = {:a=>1}
+  #   h/:a  #=> 1
+
+  alias_method :/, :[]
+
+end
+

data/work/defunct/core/facets/hash/variablize_keys.rb

@@ -0,0 +1,48 @@
+# DEPRECATED b/c of Hash#rekey and String#variablize (variablize is defined in metaid.rb).
+
+class Hash
+
+  # Converts all keys in the Hash to be String values, returning a new Hash.
+  # With a from_class parameter, limits conversion to only a certain class of keys.
+  # It defaults to nil which convert any key class.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.variablize_keys    #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
+  #   foo.inspect            #=>  { :name =>"Gavin", :wife=>:Lisa }
+
+  def variablize_keys( of_class=nil )
+    self.dup.variablize_keys!( of_class )
+  end
+
+  # Synonym for Hash#keys_to_string, but modifies the receiver in place (and returns it).
+  # With a from_class parameter, limits conversion to only a certain class of keys.
+  # It defaults to nil which convert any key class.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.variablize_keys!   #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
+  #   foo.inspect            #=>  { "@name"=>"Gavin", "@wife"=>:Lisa }
+
+  def variablize_keys!(of_class=nil)
+    raise ArgumentError, "Parameter must be a class" unless of_class.kind_of?(Class) if of_class
+    if of_class
+      self.each_key do |k|
+        if k.respond_to?(:to_s) and k.class == of_class
+          k = k.to_s
+          nk = k[0,1] != '@' ? k : "@#{k}"
+          self[nk]=self.delete(k)
+        end
+      end
+    else
+      self.each_key do |k|
+        if k.respond_to?(:to_s)
+          k = k.to_s
+          nk = k[0,1] != '@' ? k : "@#{k}"
+          self[nk]=self.delete(k)
+        end
+      end
+    end
+    self
+  end
+
+end
+

data/work/defunct/core/facets/kernel/__assign__.rb

@@ -0,0 +1,28 @@
+module Kernel
+
+  # Universal assignment. This is a meta-programming
+  # method, which allows you to assign any type of variable.
+  #
+  # TODO: This method is probably worthless. Either depreicate
+  #       Or just move to a separate file.
+  #
+  #  CREDIT: Trans
+
+  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

data/work/defunct/core/facets/kernel/__real__.rb

@@ -0,0 +1,48 @@
+# = TODO:
+#
+#   - Probably get rid of __self__ or get a new name.
+#     It is similar to #meta + #as, but just for Object/Kernel.
+
+require 'facets/functor'
+
+module Kernel
+
+  # Returns a Functor that allows one to call any
+  # Kernel or Object method bound to self, making it
+  # possible to bypass overrides of Kernel and Object
+  # methods.
+  #
+  #   class A
+  #     def object_id ; "OBTUSE" ; end
+  #   end
+  #
+  #   c = C.new
+  #   c.object_id         #=> "OBTUSE"
+  #   c.__real__.object_id    #=> 6664875832
+  #
+  # NOTE: This has been through a couple of renamings,
+  # including #__object__, #__self__, and #self.
+
+  def __real__
+    @__real__ ||= Functor.new do |meth, *args|  # &blk|
+      Object.instance_method(meth).bind(self).call(*args) # ,&blk)
+    end
+  end
+
+  #--
+  #   def as( role, &blk )
+  #     unless role.is_a?(Class)
+  #       role = self.class.const_get( role )
+  #     end
+  #     @roles ||= {}
+  #     @roles[role] ||= role.allocate
+  #     robj = @roles[role]
+  #     robj.assign_from( self )
+  #     result = robj.instance_eval( &blk )
+  #     self.assign_from( robj )  # w/o this much like namespaces
+  #     result
+  #   end
+  #++
+
+end
+

data/work/defunct/core/facets/kernel/deep_clone.rb

@@ -0,0 +1,48 @@
+module Kernel
+
+  # 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]  # >> []
+  #
+  #  CREDIT: Jan Molic
+
+  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

data/work/defunct/core/facets/kernel/instance_assume.rb

@@ -0,0 +1,66 @@
+# Deprecated b/c it can be done via instance_assign(obj.to_data).
+
+module Kernel
+
+  # 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
+  #
+  #   CREDIT: Trans
+
+  def instance_assume(obj, *vars)
+    if vars.empty?
+      vars = obj.instance_variables  # 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
+
+  # As with #instance_assume, but forces the setting of the object's
+  # instance varaibles even if the reciever doesn't have them defined.
+  #
+  # See #instance_assume.
+
+  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)
+
+end
+

data/work/defunct/core/facets/kernel/once.rb

@@ -0,0 +1,54 @@
+module Kernel
+
+  # Simple directive for making your functions faster by trading space for time.
+  # When you "memoize" a method/function using #once its results are cached so
+  # that later calls with the same arguments return results from the cache
+  # instead of recalculating them.
+  #
+  #   class T
+  #     def initialize(a)
+  #       @a = a
+  #     end
+  #     def a
+  #       "#{@a ^ 3 + 4}"
+  #     end
+  #     once :a
+  #   end
+  #
+  #   t = T.new
+  #   t.a.__id__ == t.a.__id__  #=> true
+  #
+  # Results are cached in an instance variable, so they are per-object.
+  #
+  # This method can also be used at the instance level to cache singleton
+  # methods.
+  #
+  # Note, this method also used to be aliased as #memoize, but this has been
+  # deprecated in favor of the more robust Memoizable mixin module.
+  #
+  # CREDIT Robert Feldt
+
+  def once(*ids)
+    if ids.empty?
+      @_once ||= Hash::new{|h,k| h[k]={}}
+    else
+      base = (Module === self ? self : (class << self; self; end))
+      ids.each do |m|
+        base.module_eval <<-code
+          alias_method '#{ m }:once', '#{ m }'
+          private '#{ m }:once'
+          def #{ m }(*__a__,&__b__)
+            c = once['#{ m }']
+            k = [__a__, block_given?]
+            if c.has_key? k
+              c[k]
+            else
+              c[k] = __send__('#{ m }:once',*__a__,&__b__)
+            end
+          end
+        code
+      end
+    end
+  end
+
+end

data/work/defunct/core/facets/kernel/warn_with_line.rb

@@ -0,0 +1,29 @@
+module Kernel
+
+  # DEPRECATE:
+  #   Just use:
+  #     puts __LINE__ + ": your message"
+  #     p caller
+  
+  # Outputs the current caller trace.
+  #
+  #   warn_with_line("You have been warned.")
+  #
+  # _produces_
+  #
+  #   3: "You have been warned."
+  #
+  # Note that this method depends on the output of #caller.
+  #
+  # TODO: This may be useful but the naem is wrong. It's a debug output
+  #       not a "warning" output.
+
+  def warn_with_line(msg="", fulltrace=true)
+    trac = caller(1)
+    where = trac[0].sub(/:in.*/,'')
+    STDERR.puts "#{where}: #{msg.inspect}"
+    STDERR.puts trac.map { |t| "\tfrom #{t}" } if fulltrace
+  end
+
+end
+

data/work/defunct/core/facets/method/curry.rb

@@ -0,0 +1,10 @@
+require 'facets/proc'
+
+class Method
+  # Curry a Method into a new Proc.
+
+  def curry(*args)
+    to_proc.curry(*args)
+  end
+end
+

data/work/defunct/core/facets/method/partial.rb

@@ -0,0 +1,10 @@
+require 'facets/proc/partial'
+
+class Method
+  # Convert a method into a new partial Proc.
+
+  def partial(*args)
+    to_proc.partial(*args)
+  end
+end
+

data/work/defunct/core/facets/module/attr_toggler.rb

@@ -0,0 +1,59 @@
+require 'facets/attr_tester'
+
+class Module
+
+  # Create a flaggable attribute. This creates a single methods
+  # used to set an attribute to "true".
+  #
+  #   attr_toggler :a
+  #
+  # is equivalent to
+  #
+  #   def a?
+  #     @a ? true : @a
+  #   end
+  #
+  #   def a!(value=Exception)
+  #     if Exception
+  #       @a = @a ? false : true
+  #     else 
+  #       @a = value
+  #     end
+  #     self
+  #   end
+  #
+  def attr_toggler(*args)
+    code, made = '', []
+    args.each do |a|
+      code << %{
+        def #{a}!(value=Excception)
+          if Exception
+            @a = @a ? false : true
+          else 
+            @a = value
+          end
+          self
+        end
+      }
+      made << "#{a}!".to_sym
+    end
+    module_eval code
+    made.concat(attr_tester(*args))
+    made
+  end
+
+  # Create aliases for attr_toggler.
+  #
+  # CREDIT: Trans
+
+  def alias_toggler(*args)
+    orig = args.last
+    args = args - [orig]
+    args.each do |name|
+      alias_method("#{name}!", "#{orig}!")
+      alias_method("#{name}?", "#{orig}?")
+    end
+  end
+
+end
+

data/work/defunct/core/facets/module/by_name.rb

@@ -0,0 +1,56 @@
+class Module
+
+  # <em>Note: the following documentation uses "class" because it's more common, but it
+  # applies to modules as well.</em>
+  #
+  # Given the _name_ of a class, returns the class itself (i.e. instance of Class).  The
+  # dereferencing starts at Object.  That is,
+  #
+  #   Class.by_name("String")
+  #
+  # is equivalent to
+  #
+  #   Object.const_get("String")
+  #
+  # The parameter _name_ is expected to be a Symbol or String, or at least to respond to
+  # <tt>to_str</tt>.
+  #
+  # An ArgumentError is raised if _name_ does not correspond to an existing class.  If _name_
+  # is not even a valid class name, the error you'll get is not defined.
+  #
+  # Examples:
+  #
+  #   Class.by_name("String")             # -> String
+  #   Class.by_name("::String")           # -> String
+  #   Class.by_name("Process::Sys")       # -> Process::Sys
+  #   Class.by_name("GorillaZ")           # -> (ArgumentError)
+  #
+  #   Class.by_name("Enumerable")         # -> Enumerable
+  #   Module.by_name("Enumerable")        # -> Enumerable
+  #
+  #  CREDIT: Gavin Sinclair
+
+  def self.by_name(name)
+    #result = Object.constant(name)
+    # TODO: Does self need to be Object in the following lines?
+    const  = name.to_s.dup
+    base   = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    result = const.split(/::/).inject(base){ |mod, subconst| mod.const_get(subconst) }
+
+    return result if result.kind_of?( Module )
+    raise ArgumentError, "#{name} is not a module or class"
+  end
+
+end
+
+
+=begin test
+
+  def test_by_name
+    c = ::Test::Unit::TestCase.name
+    assert_equal( ::Test::Unit::TestCase, Module.by_name(c) )
+    c = "Test::Unit::TestCase"
+    assert_equal( ::Test::Unit::TestCase, Class.by_name(c) )
+  end
+
+=end