facets 2.5.0 → 2.5.1

data/lib/core/facets/string/file.rb

@@ -0,0 +1,17 @@
+require 'facets/functor'
+
+class String
+
+  # Use fluent notation for making file directives.
+  #
+  #    '~/trans/Desktop/notes.txt'.file.mtime
+  #  
+  def file
+    f = self
+    Functor.new do |op, *a|
+      File.send(op, f, *a)
+    end
+  end
+
+end
+

data/lib/core/facets/string/xor.rb

@@ -1,9 +1,15 @@
 class String
 
-  # XOR two string.
+  # Binary XOR of two strings. 
+  #
+  #   puts "\000\000\001\001" ^ "\000\001\000\001"
+  #   puts  "\003\003\003" ^ "\000\001\002"
+  #
+  # _produces_
+  #
+  #   "\000\001\001\000"
+  #   "\003\002\001"
   #
-  # TODO: This is used by crypt.rb, it needs to be documented.
-
   def ^(aString)
     a = self.unpack('C'*(self.length))
     b = aString.unpack('C'*(aString.length))

data/lib/core/facets/to_hash.rb

@@ -1,38 +1,238 @@
+require 'enumerator' if RUBY_VERSION < "1.9"
+
+class Hash
+
+  # Any array values with less one or no elements will have the element
+  # or nil set as the value instead.
+  #
+  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+  #   h.dearray_values  #=> { :a=>1, :b=>1, :c=>3, :d=>nil }
+  #
+  # CREDIT: Trans
+
+  def dearray_values(index=0)
+    h = {}
+    each do |k,v|
+      case v
+      when Array
+        h[k] = v[index] || v[-1]
+      else
+        h[k] = v
+      end
+    end
+    h
+  end
+
+  # Any array values with less one or no elements will have the element
+  # or nil set as the value instead.
+  #
+  #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }
+  #   h.dearray_singluar_values  #=> { :a=>1, :b=>[1,2], :c=>3, :d=>nil }
+  #
+  # CREDIT: Trans
+
+  def dearray_singluar_values
+    h = {}
+    each do |k,v|
+      case v
+      when Array
+        h[k] = (v.size < 2) ? v[0] : v
+      else
+        h[k] = v
+      end
+    end
+    h
+  end
+
+end
+
+
 class Array
 
-  # Converts a two-element associative array into a hash.
+  # Converts an array into a hash. Converting an array
+  # into a hash is not a one-to-one conversion, for this
+  # reason #to_h examines at the array being converted
+  # and then dispatches the conversion to the most sutiable
+  # specialized function. There are three possiblities for this.
+  #
+  # If the array is a collection of perfect pairs, like that
+  # which Hash#to_a generates, then conversion is handled by 
+  # #to_h_flat.
   #
   #   a = [ [:a,1], [:b,2] ]
   #   a.to_h  #=> { :a=>1, :b=>2 }
   #
-  # If +arrayed+ is set it will maintain trailing arrays.
+  # If the array contains only arrays, but are not perfect pairs,
+  # then #to_h_multi is called.
+  #
+  #   a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+  #
+  # If the array contians objects other then arrays then
+  # the #to_h_splat method is called.
   #
-  #   a = [ [:a,1,2], [:b,3] ]
-  #   a.to_h(true)  #=> { :a=>[1,2], :b=>[3] }
+  #   a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
+  #   a.to_h  #=> { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
   #
-  # Note that the use of a values parameter has been deprecated
+  # Finally, a particular dispatch can be forced by 
+  # specifying the +mode+ of conversion, eg. +:multi+,
+  # +:splat+, +:flat+, +:assoc+, etc.
+  #
+  # Setting +mode+ to +true+ is the same as setting it +:multi+.
+  # This has been left in for backward compatability.
+  #
+  # NOTE: The use of a +values+ parameter has been deprecated
   # because that functionality is as simple as:
   #
   #   array1.zip(array2).to_h
   #
+  # CREDIT: Robert Klemme
   # CREDIT: Trans
+  #
+  #--
+  # The +True+ option in the case statement provides some
+  # backward compatability with the previous versions of this
+  # method.
+  #++
 
-  def to_h(arrayed=nil)
-    h = {}
-    if arrayed #or (flatten.size % 2 == 1)
-      #each{ |e| h[e.first] = e.slice(1..-1) }
-      each{ |k,*v| h[k] = v }
+  def to_h(mode=nil)
+    case mode
+    when :splat
+      return to_h_splat
+    when :flat
+      return to_h_flat
+    when :multi, true
+      return to_h_multi
+    when :assoc
+      return to_h_assoc
     else
-      #h = Hash[*flatten(1)] # TODO Use in 1.9 instead.
-      ary = []
-      each do |a|
-        Array===a ? ary.concat(a) : ary << a
+      return to_h_auto
+    end
+  end
+
+  # Converts an array into a hash. Converting an array
+  # into a hash is not a one-to-one conversion, for this
+  # reason #to_h examines at the array being converted
+  # and then dispatches the conversion to the most sutiable
+  # specialized function. There are three possiblities for this.
+  #
+  # If the array is a collection of perfect pairs, like that
+  # which Hash#to_a generates, then conversion is handled by 
+  # #to_h_flat.
+  #
+  #   a = [ [:a,1], [:b,2] ]
+  #   a.to_h  #=> { :a=>1, :b=>2 }
+  #
+  # If the array contains only arrays, but are not perfect pairs,
+  # then #to_h_multi is called.
+  #
+  #   a = [ [:a,1,2], [:b,2], [:c], [:d] ]
+  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+  #
+  # If the array contians objects other then arrays then
+  # the #to_h_splat method is called.
+  #
+  #   a = [ [:a,1,2], 2, :b, [:c,3], 9 ]
+  #   a.to_h  #=> { [:a,1,2]=>2, :b=>[:c,3], 9=>nil } 
+  #
+  def to_h_auto
+    pairs = true
+    mixed = false
+
+    each do |e|
+      case e
+      when Array
+        pairs = false if e.size > 2
+      else
+        mixed = true
       end
-      h = Hash[*ary]
+    end
+
+    if mixed
+      to_h_splat
+    elsif pairs
+      to_h_flat
+    else
+      to_h_multi
+    end
+  end
+
+  # This is equivalent to Hash[*array], but it will pad
+  # the array with a +nil+ object if there are not an even number
+  # of elements.
+  #
+  #   a = [:a,1,:b,2,:c]
+  #   a.to_h_splat  #=> { :a=>1, :b=>2, :c=>nil }
+  #
+  def to_h_splat
+    a = dup
+    a << nil if a.size % 2 == 1
+    Hash[*a]
+  end
+
+  # This is equivalent to Hash[*array.flatten], but it will pad
+  # the array with a +nil+ object if there are not an even number
+  # of elements.
+  #
+  #   a = [:a,1,[:b,2,:c]]
+  #   a.to_h_flat  #=> { :a=>1, :b=>2, :c=>nil }
+  #
+  def to_h_flat
+    a = flatten
+    a << nil if a.size % 2 == 1
+    Hash[*a]
+  end
+
+  #def to_h_flat
+  #  each_slice(2).inject({}) {|ha,(k,v)| ha[k]=v; ha}
+  #end 
+
+  # When a mixed or multi-element accociative array
+  # is used, the result is as follows:
+  #
+  #   a = [ [:a,1,2], [:b,2], [:c], :d ]
+  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+  #
+  # If the fist entry of any subelements are the same, then
+  # the value will be set to the last occuring value.
+  #
+  #   a = [ :x, [:x], [:x,1,2], [:x,3], [:x,4] ]
+  #   a.to_h_assoc  #=> { :x=>4 }
+  #
+  def to_h_assoc
+    h = {}
+    each do |k,*v| 
+      h[k] = v
+    end
+    h
+  end
+
+  # When a mixed or multi-element accociative array
+  # is used, the result is as follows:
+  #
+  #   a = [ [:a,1,2], [:b,2], [:c], :d ]
+  #   a.to_h  #=> { :a=>[1,2], :b=>[2], :c=>[], :d=>[] }
+  #
+  # If the fist entry of the subelements is the same, then
+  # the values will be merged using #concat.
+  #
+  #   a = [ [:a,1,2], [:a,3], [:a,4], [:a], :a ]
+  #   a.to_h_multi  #=> { :a=>[1,2,3,4,nil,nil] }
+  #
+  def to_h_multi
+    h = {}
+    each do |k,*v| 
+      h[k] ||= []
+      h[k].concat(v)
     end
     h
   end
 
+  #def to_h_multi
+  #  inject({}) {|h,a| h[a.first] = a[1..-1]; h}
+  #end
+
+  # Is this a good idea?
   #def to_hash
   #  h = {}
   #  each_with_index do |v, i|
@@ -62,8 +262,8 @@ module Enumerable
   #
   # CREDIT: Trans
 
-  def to_h(arrayed=nil)
-    to_a.to_h(arrayed)
+  def to_h(mode=nil)
+    to_a.to_h(mode)
   end
 
   #def to_hash
@@ -85,3 +285,60 @@ class NilClass
 
 end
 
+
+if RUBY_VERSION < "1.9"
+
+  class Enumerable::Enumerator
+  
+    # Convert an Enumerable::Enumerator object directly into a hash.
+    # 
+    #   e = [1,2,3,4,5].to_enum
+    #   e.to_h  #=> {5=>nil, 1=>2, 3=>4}
+    #   e2 = [1,2,1,3,1,5].to_enum
+    #   e2.to_h #=> {1=>5}
+    #   e3 = [[1,:a],[2,:b],[3,:c]].to_enum
+    #   e3.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
+    #
+    # CREDIT: Sandor Szücs
+
+    def to_h(mode=nil)
+      to_a.to_h(mode)
+    end
+  end
+
+else
+
+  class Enumerator
+
+    # Convert an Enumerator object directly into a hash.
+    # 
+    #   e3 = [[1,:a],[2,:b],[3,:c]].to_enum
+    #   e3.to_h #=> { 1=>:a, 2=>:b, 3=>:c }
+    #
+    #   e1 = [1,2,3,4,5].to_enum
+    #   e1.to_h  #=> {5=>nil, 1=>2, 3=>4}
+    #
+    #   e2 = [1,2,1,3,1,5].to_enum
+    #   e2.to_h #=> {1=>5}
+    #
+    #
+    # CREDIT: Sandor Szücs
+
+    def to_h(mode=nil)
+      to_a.to_h(mode)
+    end
+
+    #def to_h
+    #  h = {}
+    #  loop do
+    #    x,y = self.next
+    #    h[x] ||= nil
+    #    y = self.next unless y
+    #    h[x] = y
+    #  end
+    #  return h
+    #end
+  end
+
+end
+

data/lib/core/facets/unboundmethod/name.rb

@@ -1,9 +1,11 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+if RUBY_VERSION < '1.9'
 
   class UnboundMethod
 
     # Return the name of the method.
-    # Is this already in 1.9+ ?
+    #
+    # Be aware that in ruby 1.9 UnboundMethod#name is defined already,
+    # but it returns a Symbol not a String.
     #
     #   class X
     #     def foo; end

data/lib/lore/facets/ostruct.rb

@@ -125,6 +125,7 @@ class OpenStruct
   def instance_delegate
     @table
   end
+
   alias ostruct_delegate instance_delegate
 
   # Insert/update hash data on the fly.
@@ -134,6 +135,7 @@ class OpenStruct
   #   o.a  #=> 2
   #
   def ostruct_update(other)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
     #other = other.to_hash  #to_h ?
     for k,v in other
       @table[k.to_sym] = v
@@ -166,6 +168,7 @@ class OpenStruct
   #   o.a  #=> 2
   #
   def __update__(other)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
     #other = other.to_hash #to_h?
     for k,v in other
       @table[k.to_sym] = v

data/lib/more/facets/association.rb

@@ -96,19 +96,40 @@
 #   IPAddr
 #   Process::Status
 #
-class Association
+# TODO: Should associations be singleton?
 
+class Association
   include Comparable
 
-  attr_accessor :index, :value
+  class << self
+    # Store association references.
+    def reference
+      @reference ||= Hash.new{ |h,k,v| h[k]=[] }
+    end
+
+    def [](index, value)
+      new(index, value)
+    end
+
+    #def new(index, value)
+    #  lookup[[index, value]] ||= new(index, value)
+    #end
 
-  def self.[](*args)
-    new(*args)
+    #def lookup
+    #  @lookup ||= {}
+    #end
   end
 
+  attr_accessor :index
+  attr_accessor :value
+
   def initialize(index, value=nil)
     @index = index
     @value = value
+
+    unless index.associations.include?(value)
+      index.associations << value
+    end
   end
 
   def <=>(assoc)
@@ -135,22 +156,17 @@ class Association
     [ @index, @value ]
   end
 
-  # Store association references.
-
-  REFERENCE = Hash.new{ |h,k,v| h[k]=[] }
-
   # Object extensions.
-
+  #
   module Kernel
 
     # Define an association with +self+.
     def >>(to)
-      REFERENCE[self] << to
       Association.new(self, to)
     end
 
     def associations
-      REFERENCE[self]
+      Association.reference[self]
     end
 
   end
@@ -163,7 +179,7 @@ end
 
 
 #--
-# Setup the >> method in classes that use it  already.
+# Setup the >> method in classes that use it already.
 #
 # This is a bad idea b/c it can cause backward compability issues.
 #