facets 2.8.4 → 2.9.0.pre.1

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

@@ -0,0 +1,18 @@
+class File
+
+  # Cleans up a filename to ensure it will work on a filesystem.
+  #
+  #   File.sanitize("yo+baby!")   #=> 'yo+baby_'
+  #   File.sanitize(".what&up")  #=> '.what_up'
+  #
+  # CREDIT: George Moschovitis
+
+  def self.sanitize(filename)
+    filename = File.basename(filename.gsub("\\", "/")) # work-around for IE
+    filename.gsub!(/[^a-zA-Z0-9\.\-\+_]/,"_")
+    filename = "_#{filename}" if filename =~ /^\.+$/
+    filename
+  end
+
+end
+

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

@@ -4,7 +4,7 @@ class File
   # This differs from <tt>File.split</tt>, which divides the path into
   # only two parts, directory path and basename.
   #
-  #   File.split_all("a/b/c") =>  ['a', 'b', 'c']
+  #   File.split_all("a/b/c")  #=> ['a', 'b', 'c']
   #
   # CREDIT: Trans
 

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

@@ -1,21 +1,23 @@
-# DEPRECATE
-require 'facets/file/create'
-require 'facets/file/append'
-require 'facets/file/writelines'
-
 class File
 
-  # Writes the given data to the given path and closes the file.  This is
-  # done in binary mode, complementing <tt>IO.read</tt> in standard Ruby.
-  #
-  # Returns the number of bytes written.
-  #
-  # CREDIT: Gavin Sinclair
+  unless defined?(write)  # 1.9+
+
+    # Writes the given data to the given path and closes the file.  This is
+    # done in binary mode, complementing <tt>IO.read</tt> in standard Ruby.
+    #
+    #   str = 'The content for the file'
+    #   File.write('tmp/write.txt', str)
+    #
+    # Returns the number of bytes written.
+    #
+    # CREDIT: Gavin Sinclair
 
-  def self.write(path, data)
-    File.open(path, "wb") do |file|
-      return file.write(data)
+    def self.write(path, data)
+      File.open(path, "wb") do |file|
+        return file.write(data)
+      end
     end
+
   end
 
 end

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

@@ -9,7 +9,10 @@ class File
   # appends newlines if necessary.  In this small way, +readlines+ and
   # +writelines+ are not exact opposites.
   #
-  # Returns +nil+.
+  #   data = ['The content', ['for the file']]
+  #   File.writelines('tmp/writelines.txt', data)
+  #
+  # Returns number of lines written.
   #
   # CREDIT: Noah Gibbs, Gavin Sinclair
 
@@ -17,6 +20,7 @@ class File
     File.open(path, "wb") do |file|
       file.puts(data)
     end
+    data.size
   end
 
 end

data/lib/core/facets/functor.rb

@@ -1,73 +1,73 @@
-# = Functor
-#
-# = Synopsis
-#
 # By definition a Functor is simply a first class method, but these are common
-# in the form of Method and Proc. So for Ruby a Functor is a bit more specialized
+# in the form of Method and Proc. So for Ruby a Functor is a more specialized
 # as a Higher-order function or Metafunction. Essentally, a Functor can vary
 # its behavior accorrding to the operation applied to it.
 #
 #   f = Functor.new { |op, x| x.send(op, x) }
-#   f + 1  #=> 2
-#   f + 2  #=> 4
-#   f + 3  #=> 6
-#   f * 1  #=> 1
-#   f * 2  #=> 4
-#   f * 3  #=> 9
-#
-# == Author
-#
-# * Thomas Sawyer
-#
-# == History
-#
-# * 2006-11-04 trans Deprecated #functor_function, renamed to #to_proc.
-# * 2006-11-04 trans All methods are now private except __ and #binding.
-#
-# == Todo
-#
-# * Consider renaming Functor to... ?
-#
-# == Copying
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
+#   (f + 1)  #=> 2
+#   (f + 2)  #=> 4
+#   (f + 3)  #=> 6
+#   (f * 1)  #=> 1
+#   (f * 2)  #=> 4
+#   (f * 3)  #=> 9
+#
+class Functor #< BasicObject
 
+  EXCEPTIONS = [:binding, :inspect, :object_id]
+  if defined?(::BasicObject)
+    EXCEPTIONS.concat(::BasicObject.instance_methods)
+    EXCEPTIONS.uniq!
+    EXCEPTIONS.map!{ |m| m.to_sym }
+  end
 
-# By definition a Functor is simply a first class method, but these are common
-# in the form of Method and Proc. So for Ruby a Functor is a more specialized
-# as a Higher-order function or Metafunction. Essentally, a Functor can vary
-# its behavior accorrding to the operation applied to it.
-#
-#   f = Functor.new { |op, x| x.send(op, x) }
-#   f + 1  #=> 2
-#   f + 2  #=> 4
-#   f + 3  #=> 6
-#   f * 1  #=> 1
-#   f * 2  #=> 4
-#   f * 3  #=> 9
-#
-class Functor
+  #
+  alias :__class__ :class
+
+  ## If Functor were built-in to Ruby this would not be
+  ## needed since exceetions could just be added directly.
+  ##$FUNCTOR_EXCEPTIONS ||= [:binding, :undefine_method]
+
+  ## TODO: This will not work when BasicObject is utilized. How to fix?
+  ##def self.honor_exceptions
+  ##  $FUNCTOR_EXCEPTIONS.each{ |name|
+  ##    next if method_defined?(name)
+  ##    eval %{
+  ##      def #{name}(*a,&b)
+  ##        super(*a, &b)
+  ##      end
+  ##    }
+  ##  }
+  ##end
 
   # Privatize all methods except vital methods and #binding.
-  private(*instance_methods.select { |m| m !~ /(^__|^binding$)/ })
+  instance_methods(true).each do |m|
+    next if m.to_s =~ /^__/
+    next if EXCEPTIONS.include?(m.to_sym)
+    undef_method(m)
+  end
 
+  #
   def initialize(&function)
     @function = function
   end
 
+  #
   def to_proc
     @function
   end
 
+  ##def inspect
+  ##  #"#<Functor:#{object_id} #{method_missing(:inspect)}>"    # hex id ?
+  ##  "#{method_missing(:inspect)}"
+  ##end
+
+  ## Needed?
+  ##def send(op, *a, &b)
+  ##  method_missing(op, *a, &b)
+  ##end
+
+  private
+
   # Any action against the functor is processesd by the function.
   def method_missing(op, *args, &blk)
     @function.call(op, *args, &blk)
@@ -75,3 +75,4 @@ class Functor
 
 end
 
+# Copyright (c) 2004 Thomas Sawyer (Ruby License)

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

@@ -7,13 +7,13 @@ class Hash
   # Returns a reference to the Hash.
   #
   #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
-  #   foo.alias!('name',:name)     => { :name=>'Gavin', 'name'=>'Gavin', 'wife'=>:Lisa }
+  #   foo.alias!('name',:name)     #=> { :name=>'Gavin', 'name'=>'Gavin', 'wife'=>:Lisa }
   #
   #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
-  #   foo.alias!('spouse','wife')  => { :name=>'Gavin', 'wife'=>:Lisa, 'spouse'=>:Lisa }
+  #   foo.alias!('spouse','wife')  #=> { :name=>'Gavin', 'wife'=>:Lisa, 'spouse'=>:Lisa }
   #
   #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
-  #   foo.alias!('bar','foo')      => { :name=>'Gavin', 'wife'=>:Lisa }
+  #   foo.alias!('bar','foo')      #=> { :name=>'Gavin', 'wife'=>:Lisa }
   #
   # Note that if the _oldkey_ is reassigned, the reference will no longer exist,
   # and the _newkey_ will remain as it was.

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

@@ -1,11 +1,17 @@
 class Hash
 
-  # Turn a hash into arguments.
+  # Turn a hash into a method arguments.
   #
   #   h = { :list => [1,2], :base => "HI" }
-  #   h.argumentize #=> [ [], { :list => [1,2], :base => "HI" } ]
-  #   h.argumentize(:list)   #=> [ [1,2], { :base => "HI" } ]
-  #   h.argumentize(:base)   #=> [ ["HI"], { :list => [1,2] } ]
+  #
+  # Without an argument field.
+  #
+  #   h.argumentize #=> [ { :list => [1,2], :base => "HI" } ]
+  #
+  # With an argument field.
+  #
+  #   h.argumentize(:list)   #=> [ 1, 2, { :base => "HI" } ]
+  #   h.argumentize(:base)   #=> [ "HI", { :list => [1,2] } ]
   #
   def argumentize(args_field=nil)
     config = dup

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

@@ -1,24 +1,22 @@
 class Hash
 
-  #  Hash which auto initializes it's children.
+  # Hash which auto initializes it's children.
   #
-  #   ah = Hash.autonew
-  #   ah['section one']['param one'] = 4
-  #   ah['section one']['param two'] = 5
-  #   ah['section one']['param three'] = 2
-  #   ah['section one']['param four'] = 3
+  #   h = Hash.autonew
+  #   h['s1']['p1'] = 4
+  #   h['s1']['p2'] = 5
+  #   h['s1']['p3'] = 2
+  #   h['s1']['p4'] = 3
   #
-  #   p ah
-  #   # {"section one"=>{"param one"=>4, "param four"=>3, "param three"=>2, "param two"=>5}}
+  #   h #=> {"s1"=>{"p1"=>4, "p4"=>3, "p3"=>2, "p2"=>5}}
   #
-  #   p ah['section one'].keys
-  #   # ["param one", "param four", "param three", "param two"]
+  #   h['s1'].keys.sort
+  #   #=> ["p1", "p2", "p3", "p4"]
   #
   # CREDIT: Trans, Jan Molic
 
   def self.autonew(*args)
-    #new(*args){|a,k| a[k] = self.class::new(*args)}
-    leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+    leet = lambda{ |hsh, key| hsh[key] = new( &leet ) }
     new(*args,&leet)
   end
 

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

@@ -3,74 +3,60 @@ class Hash
   # Merge the values of this hash with those from another, setting all values
   # to be arrays representing the values from both hashes.
   #
-  #   { :a=>1, :b=>2 }.collate :a=>3, :b=>4, :c=>5
+  #   { :a=>1, :b=>2 }.collate(:a=>3, :b=>4, :c=>5)
   #   #=> { :a=>[1,3], :b=>[2,4], :c=>[5] }
   #
-  # CREDIT: Tilo Sloboda
-  # CREDIT: Gavin Kistner (Phrogz)
+  # CREDIT: Tilo Sloboda, Gavin Kistner (Phrogz)
 
-  def collate(other_hash)
+  def collate(other)
     h = Hash.new
-    # Prepare, ensuring every existing key is already an Array
+    (keys + other.keys).each do |key|
+      h[key] = []
+    end
     each do |key, value|
-      if value.is_a?(Array)
-        h[key] = value
-      else
-        h[key] = [value]
-      end
+      h[key] << value
     end
-    # Collate with values from other_hash
-    other_hash.each do |key, value|
-      if h[key]
-        if value.is_a?(Array)
-          h[key].concat(value)
-        else
-          h[key] << value
-        end
-      elsif value.is_a?(Array)
-        h[key] = value
-      else
-        h[key] = [value]
-      end
+    other.each do |key, value|
+      h[key] << value
     end
-    #each{ |key, value| value.uniq! } if options[ :uniq ]
+    h.each{ |k,v| v.flatten! }
     h
   end
 
   # The same as #collate, but modifies the receiver in place.
-
   def collate!(other_hash)
-    result = self.collate(other_hash)
-    self.replace(result)
+    result = collate(other_hash)
+    replace(result)
   end
 
-  # Old version.
-  #def collate!(other_hash)
-  #  # Prepare, ensuring every existing key is already an Array
-  #  each do |key, value|
-  #    if value.is_a?(Array)
-  #      self[key] = value
-  #    else
-  #      self[key] = [value]
-  #    end
-  #  end
-  #  # Collate with values from other_hash
-  #  other_hash.each do |key, value|
-  #    if self[key]
+  # Old version ...
+  #
+  #  def collate!(other_hash)
+  #    # Prepare, ensuring every existing key is already an Array
+  #    each do |key, value|
   #      if value.is_a?(Array)
-  #        self[key].concat( value )
+  #        self[key] = value
+  #      else
+  #        self[key] = [value]
+  #      end
+  #    end
+  #    # Collate with values from other_hash
+  #    other_hash.each do |key, value|
+  #      if self[key]
+  #        if value.is_a?(Array)
+  #          self[key].concat( value )
+  #        else
+  #          self[key] << value
+  #        end
+  #      elsif value.is_a?(Array)
+  #        self[key] = value
   #      else
-  #        self[key] << value
+  #        self[key] = [value]
   #      end
-  #    elsif value.is_a?(Array)
-  #      self[key] = value
-  #    else
-  #      self[key] = [value]
   #    end
+  #    #each{ |key, value| value.uniq! } if options[ :uniq ]
+  #    self
   #  end
-  #  #each{ |key, value| value.uniq! } if options[ :uniq ]
-  #  self
-  #end
 
 end
 

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

@@ -1,5 +1,3 @@
-require 'facets/enumerable/count'
-
 class Hash
 
   # Like Enumerable#count, but counts hash values.

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

@@ -2,13 +2,40 @@ require 'facets/functor'
 
 class Hash
 
-  # TODO: The name of this method may change.
+  # Access to a hash as if it were an OpenStruct.
   #
+  #   h = {:a=>1, :b=>2}
+  #
+  #   h.data.a  #=> 1
+  #   h.data.b  #=> 2
+  #   h.data.c  #=> nil
+  #
+  #   h.data.c = 3
+  #   h.data.c  #=> 3
+  #
+  #   h.data.a?  #=> true
+  #   h.data.d?  #=> false
+  #
+  # TODO: Change name of Hash#data to something better?
+  #
+  # TODO: Is this really a method worth having?
   def data
-    Functor.new() do |op| 
-      self[op]
+    this = self
+    Functor.new do |op, *a|
+      case op.to_s
+      when /\=$/
+        op = op.to_s.chomp('=')
+        this[op] = a.first
+      when /\?$/
+        op = op.to_s.chomp('?')
+        this.key?(op.to_s) || this.key?(op.to_sym)
+      when /\!$/
+        op = op.to_s.chomp('!')
+        this[op] # ???
+      else
+        this[op.to_s] || this[op.to_sym]
+      end
     end
   end
 
 end
-