facets 2.8.2 → 2.8.3

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

@@ -0,0 +1,36 @@
+class File
+
+  # Takes a file name string and returns or changes its extension.
+  #
+  # Without a new extension argument, returns the extension of the
+  # file name. In this respect #ext is like #extname, but unlike
+  # #extname it does not include the dot prefix.
+  #
+  # With a new extension argument, changes the exension of the file
+  # name to the new extension and returns it.
+  #
+  # Examples:
+  #
+  #   File.ext('file.rb')          => 'rb'
+  #   File.ext('file.rb', 'txt')   => 'file.txt'
+  #   File.ext('file.rb', '.txt')  => 'file.txt'
+  #   File.ext('file.rb', '')      => 'file'
+  #
+  # This method can be used with String#file for more object-oriented notation.
+  #
+  #   'file.rb'.file.ext('txt')   => 'file.txt'
+  #
+  # CREDIT: Lavir the Whiolet
+
+  def self.ext(filename, new_ext=nil)
+    old_ext = extname(filename)
+    if new_ext == nil
+      old_ext.sub(/^\./, '')
+    else
+      new_ext = '.' + new_ext unless (new_ext.empty? || new_ext[0,1] == '.')
+      filename.chomp(old_ext) + new_ext
+    end
+  end
+
+end
+

data/lib/core/facets/hash/graph.rb

@@ -0,0 +1,18 @@
+require 'facets/enumerable/mash'
+
+class Hash
+
+  # In place version of #graph.
+  #
+  # NOTE: Hash#graph! is only useful for Hash.
+  # It is not generally applicable to Enumerable.
+
+  def graph!(&yld)
+    replace(graph(&yld))
+  end
+
+  # Alias for #graph! as an alliteration for "map hash".
+  alias_method :mash!, :graph!
+
+end
+

data/lib/core/facets/hash/mash.rb

@@ -1,18 +1 @@
-require 'facets/enumerable/mash'
-
-class Hash
-
-  # In place version of #mash.
-  #
-  #   NOTE: Hash#mash! is only useful for Hash. It is not generally
-  #         applicable to Enumerable.
-
-  def mash!(&yld)
-    replace(mash(&yld))
-  end
-
-  # Alias for #mash!. This is the original name for this method.
-  alias_method :graph!, :mash!
-
-end
-
+require 'facets/hash/graph'

data/lib/core/facets/hash/recursive.rb

@@ -0,0 +1,180 @@
+class Hash
+
+  # Apply a block to hash, and recursively apply that block
+  # to each subhash.
+  #
+  #   h = {:a=>1, :b=>{:b1=>1, :b2=>2}}
+  #   h.recursively{|h| h.rekey(&:to_s) }
+  #   => {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
+  #
+  def recursive(opts={}, &block)
+    if block
+      h = inject({}) do |hash, (key, value)|
+        if value.is_a?(Hash)
+          hash[key] = value.recursive(&block)
+        else
+          hash[key] = value
+        end
+        hash
+      end
+      yield h
+    else
+      Recursor.new(self, opts)
+    end
+  end
+
+  #
+
+  def recursive!(&block)
+    r = recursive(&block)
+    raise TypeError unless Hash === r
+    replace(r)
+  end
+
+  #
+  class Recursor
+
+    #
+    def initialize(enum, opts)
+      @enum = enum
+      @opts = opts
+    end
+
+    # Returns a new hash created by traversing the hash and its subhashes,
+    # executing the given block on the key and value. The block should
+    # return a 2-element array of the form +[key, value]+.
+    #
+    #   h = { "A"=>"A", "B"=>"B", { "X"=>"X" } }
+    #
+    #   h.recursive_each{ |k,v| p [k.downcase, v] }
+    #
+    # produces
+    #
+    #   ["a", "A"]
+    #   ["b", "B"]
+    #   ["x", "X"]
+    #
+    # CREDIT: Trans
+
+    def each(&block)
+      @enum.each do |k,v|
+        if Hash === v
+          v = v.recursive.each(&block)
+        elsif v.respond_to?(:to_hash)
+          v = v.to_hash.recursive.each(&block)
+        end
+        block.call(k,v)
+      end
+      #@enum.each do |k,v|
+      #  if Hash === v
+      #    v.recursive.each(&block)
+      #  else
+      #    block.call(k,v)
+      #  end
+      #end
+    end
+
+    # Returns a new hash created by traversing the hash and its subhashes,
+    # executing the given block on the key and value. The block should
+    # return a 2-element array of the form +[key, value]+.
+    #
+    #   h = { "A"=>"A", "B"=>"B", { "X"=>"X" } }
+    #
+    #   g = h.recursive_map{ |k,v| [k.downcase, v] }
+    #
+    #   g  #=> [["a", "A"], ["b", "B"], [["x", "X"]]]
+    #
+    # CREDIT: Trans
+
+    def map(&block)
+      @enum.inject([]) do |a,(k,v)|
+        if Hash === v
+          v = v.recursive.map(&block)
+        elsif v.respond_to?(:to_hash)
+          v = v.to_hash.recursive.map(&block)
+        end
+        nk, nv = block.call(k,v)
+        a << [nk, nv]
+        a
+      end
+    end
+
+    # In-place rendition of #recursive_map.
+
+    def map!(&b)
+      @enum.replace(map(&b))
+    end
+
+    # Returns a new hash created by traversing the hash and its subhashes,
+    # executing the given block on the key and value. The block should
+    # return a 2-element array of the form +[key, value]+.
+    #
+    #   h = {"A"=>"A", "B"=>"B", {"X"=>"X"}}
+    #
+    #   g = h.recursive_graph{ |k,v| [k.downcase, v] }
+    #
+    #   g  #=> {"a"=>"A", "b"=>"B", {"x"=>"X"}}
+    #
+    # CREDIT: Trans
+
+    def graph(&block)
+      @enum.inject({}) do |h,(k,v)|
+        if Hash === v
+          v = v.recursive.graph(&block)
+        elsif v.respond_to?(:to_hash)
+          v = v.to_hash.recursive.graph(&block)
+        end
+        nk, nv = block.call(k,v)
+        h[nk] = nv
+        h
+      end
+    end
+
+    # In place version of traverse, which traverses the hash and its
+    # subhashes, executing the given block on the key and value.
+    #
+    #   h = { "A"=>"A", "B"=>"B" }
+    #
+    #   h.traverse! { |k,v| [k.downcase, v] }
+    #
+    #   h  #=> { "a"=>"A", "b"=>"B" }
+    #
+    # CREDIT: Trans
+
+    def graph!(&block)
+      @enum.replace(graph(&block))
+    end
+
+    # Same as Hash#merge but recursively merges sub-hashes.
+
+    def merge(other)
+      hash = @enum.dup
+      other.each do |key, value|
+        myval = @enum[key]
+        if value.is_a?(Hash) && myval.is_a?(Hash)
+          hash[key] = myval.recursive.merge(value)
+        else
+          hash[key] = value
+        end
+      end
+      hash
+    end
+
+    # Same as Hash#merge! but recursively merges sub-hashes.
+
+    def merge!(other)
+      other.each do |key, value|
+        myval = @enum[key]
+        if value.is_a?(Hash) && myval.is_a?(Hash)
+          myval.recursive.merge!(value)
+        else
+          @enum[key] = value
+        end
+      end
+      @enum
+    end
+
+  end
+
+end
+

data/lib/core/facets/hash/recursive_merge.rb

@@ -1,6 +1,9 @@
 class Hash
 
   # Same as Hash#merge but recursively merges sub-hashes.
+  #
+  # DEPRECATE: This method will be deprecated in favor of
+  # <code>recursive.merge</code>.
 
   def recursive_merge(other)
     hash = self.dup
@@ -16,6 +19,9 @@ class Hash
   end
 
   # Same as Hash#merge! but recursively merges sub-hashes.
+  #
+  # DEPRECATE: This method will be deprecated in favor of
+  # <code>recursive.merge!</code>.
 
   def recursive_merge!(other)
     other.each do |key, value|

data/lib/core/facets/hash/recursively.rb

@@ -8,6 +8,7 @@ class Hash
   #   => {"a"=>1, "b"=>{"b1"=>1, "b2"=>2}}
   #
   def recursively(&block)
+    warn "Use #recusive instead of #recursively for future versions"
     h = inject({}) do |hash, (key, value)|
       if value.is_a?(Hash)
         hash[key] = value.recursively(&block)
@@ -19,11 +20,10 @@ class Hash
     yield h
   end
 
-  #
+  # In place form of #recursively.
 
   def recursively!(&block)
     replace(recursively(&block))
   end
 
 end
-

data/lib/core/facets/hash/to_module.rb

@@ -0,0 +1,26 @@
+class Hash
+
+  # Convert a hash into a mixin.
+  #
+  # CREDIT: Jay Fields
+  #
+  #--
+  # TODO: Consider #to_object option.
+  #++
+
+  def to_module
+    hash = self
+    Module.new do
+      hash.each do |key, value|
+        define_method key do
+          value #.to_object
+        end
+      end
+    end
+  end
+
+  #def to_object
+  #  Object.new.extend(to_module)
+  #end
+end
+

data/lib/core/facets/hash/to_proc.rb

@@ -24,11 +24,11 @@ class Hash
   # A fault-tolerent version of #to_proc.
   #
   # It works just like #to_proc, but the block will make
-  # sure# the object responds to the assignment.
+  # sure the object responds to the assignment.
   #
   # CREDIT: Trans
 
-  def to_proc_with_reponse
+  def to_proc_with_response
     lambda do |o|
       self.each do |k,v|
         ke = "#{k}="

data/lib/core/facets/hash/traverse.rb

@@ -4,22 +4,26 @@ class Hash
   # executing the given block on the key and value. The block should
   # return a 2-element array of the form +[key, value]+.
   #
-  #   h = { "A"=>"A", "B"=>"B" }
-  #   g = h.traverse { |k,v| [k.downcase, v] }
-  #   g  #=> { "a"=>"A", "b"=>"B" }
+  #   h = {"A"=>"A", "B"=>"B", {"X"=>"X"}}
+  #
+  #   g = h.traverse{ |k,v| [k.downcase, v] }
   #
-  # TODO: Contrast these to recursibely --we may not need both.
+  #   g  #=> {"a"=>"A", "b"=>"B", {"x"=>"X"}}
   #
-  # TODO: Testing value to see if it is a Hash also catches subclasses of Hash.
-  #       This is probably not the right thing to do and should catch Hashes only (?)
+  # NOTE: Hash#traverse is the same as <code>recursive.graph</code> and
+  # will likely be deprecated in the future because of it.
   #
   # CREDIT: Trans
 
-  def traverse(&b)
+  def traverse(&block)
     inject({}) do |h,(k,v)|
-      v = ( Hash === v ? v.traverse(&b) : v )
-      nk, nv = b[k,v]
-      h[nk] = nv #( Hash === v ? v.traverse(base,&b) : nv )
+      if Hash === v
+        v = v.traverse(&block)
+      elsif v.respond_to?(:to_hash)
+        v = v.to_hash.traverse(&block)
+      end
+      nk, nv = block.call(k,v)
+      h[nk] = nv
       h
     end
   end
@@ -28,13 +32,15 @@ class Hash
   # subhashes, executing the given block on the key and value.
   #
   #   h = { "A"=>"A", "B"=>"B" }
-  #   h.traverse! { |k,v| [k.downcase, v] }
+  #
+  #   h.traverse!{ |k,v| [k.downcase, v] }
+  #
   #   h  #=> { "a"=>"A", "b"=>"B" }
   #
   # CREDIT: Trans
 
-  def traverse!(&b)
-    self.replace( self.traverse(&b) )
+  def traverse!(&block)
+    replace(traverse(&block))
   end
 
 end

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

@@ -0,0 +1,63 @@
+module Kernel
+
+  # Assign via writer using a arguments, hash or
+  # associative array, and son on, or assign via 
+  # a block.
+  #
+  # Using name-value arguments:
+  #
+  #   object.assign(:a, 1)
+  #   object.assign(:b, 2)
+  #
+  # Using a hash:
+  #
+  #   object.assign( :a => 1, :b => 2 )
+  #
+  # Use an associative array:
+  #
+  #   object.assign( [[:a, 1], [:b, 2]] )
+  #
+  # Using a block:
+  #
+  #   object.assign do |s|
+  #     s.a = 1
+  #     s.b = 2
+  #   end
+  #
+  # These are all equivalent to:
+  #
+  #   object.a = 1
+  #   object.b = 2
+  #
+  # Unless assigned via a block, undefined setters will not
+  # raise an error if they do not exist. They will simply be
+  # skipped.
+  #
+  # Using an associative array instead of hash guarentees
+  # order of assignemnt for older versions of Ruby (< 1.8.7).
+  #
+  # TODO: Should this be called #set instead? Consider
+  # Module#set in this question, and also #set_from as
+  # the alias of #assign_from.
+
+  def assign(data=nil, value=Exception) #:yield:
+    if data
+      if value==Exception
+        data.each do |(k,v)|
+          __send__("#{k}=", v) if respond_to?("#{k}=")
+        end
+      else
+        __send__("#{data}=", value) if respond_to?("#{data}=")
+      end
+    end
+    yield(self) if block_given?
+    self
+  end
+
+  # DEPRECATE: Use #assign instead.
+  def populate(*a,&b)
+    warn 'use #assign instead of #populate for future versions'
+    assign(*a,&b)
+  end
+end
+