facets 1.7.46 → 1.8.0

data/lib/facets/core/fileutils/staged.rb

@@ -0,0 +1,3 @@
+# stub
+require 'facets/core/fileutils/stage.rb'
+

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

@@ -0,0 +1,20 @@
+
+class Hash
+
+  # As with #store but only if the key isn't
+  # already in the hash.
+  #--
+  # ??? Would #store? be a better name?
+  #++
+
+  def insert(name, value)
+    if key?(name)
+      false
+    else
+      store(name,value)
+      true
+    end
+  end
+
+end
+

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

@@ -0,0 +1,29 @@
+
+class Hash
+
+  # Operator for merge.
+
+  def +(other)
+    merge(other)
+  end
+
+  # Operator for remove hash paris. If another hash is given
+  # the pairs are only removed if both key and value are equal.
+  # If an array is given then mathcing keys are removed.
+
+  def -(other)
+    h = self.dup
+    if other.respond_to?(:to_ary)
+      other.to_ary.each do |k|
+        h.delete(k)
+      end
+    else
+      other.each do |k,v|
+        if h.key?(k)
+          h.delete(k) if value == h[k]
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,37 @@
+
+class Hash
+
+  # Hash intersection. Two hashes intersect
+  # when their pairs are equal.
+  #
+  #   {:a=>1,:b=>2} & {:a=>1,:c=>3}  #=> {:a=>1}
+  #
+  # A hash can also be intersected with an array
+  # to insterstec keys only.
+  #
+  #   {:a=>1,:b=>2} & [:a,:c]  #=> {:a=>1}
+  #
+  # The later form is simalar to #pairs_at. The differ only
+  # in that #pairs_at will return a nil value for a key
+  # not in the hash, but #& will not.
+
+  def &(other)
+    case other
+    when Array
+      k = (keys & other)
+      Hash[*(k.zip(values_at(*k)).flatten)]
+    else
+      Hash.new[*(to_a & other.to_a).flatten]
+    end
+  end
+
+  # Operator for reverse_merge.
+
+  def |(other)
+    other.merge self
+  end
+
+end
+
+
+# TODO Write tests for Hash#| and Hash #&

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

@@ -0,0 +1,17 @@
+
+class Hash
+
+  # Like merge operator '+' but merges in reverse order.
+  #  
+  #   h1 = { :a=>1 }
+  #   h2 = { :a=>2, :b=>3 }
+  #
+  #   h1 + h2  #=> { :a=>2, :b=>3 }
+  #   h1 * h2  #=> { :a=>1, :b=>3 }
+  #
+  def *(other)
+     other.merge self
+  end
+
+end
+

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

@@ -0,0 +1,2 @@
+# stub
+require 'facets/core/hash/op_and.rb'

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

@@ -0,0 +1,2 @@
+# stub
+require 'facets/core/hash/op_add.rb'

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

@@ -0,0 +1,17 @@
+
+class Hash
+
+  # Return a new hash with the include entires.
+  #
+  #   {:a=>1,:b=>2}.pairs_at(:a,:c)  #=> {:a=>1, :c=>nil}
+  #
+  # The later form is equivalent to #pairs_at.
+
+  def pairs_at( *keys )
+    keys.inject({}) {|h,k| h[k] = self[k]; h}
+  end
+
+end
+
+
+# TODO Write tests for Hash#pairs_at.

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

@@ -0,0 +1,89 @@
+#--
+# CREDIT Gavin Sinclair -- Adapted fron #convert_keys
+#++
+
+require 'facets/core/symbol/to_proc'
+
+class Hash
+
+  # Converts all keys in the Hash accroding to the given block.
+  # If the block return +nil+ for given key, then that key will be
+  # left intact.
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.rekey{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect              #=>  { :name =>"Gavin", :wife=>:Lisa }
+  #
+
+  def rekey( meth=nil, &block )
+    raise ArgumentError, "2 for 1" if meth and block
+    dup.send(:rekey!, meth, &block)
+  end
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+
+  def rekey!( meth=nil, &block )
+    meth = :to_sym unless meth or block
+    raise ArgumentError, "2 for 1" if meth and block
+    block = meth.to_sym.to_proc if meth
+    keys.each do |k|
+      nk = block[k]
+      self[nk]=delete(k) if nk
+    end
+    self
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestHash < Test::Unit::TestCase
+
+    def test_01
+      foo = { :a=>1, :b=>2 }
+      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey{|k|k.to_s} )
+      assert_equal( { :a =>1, :b=>2 }, foo  )
+    end
+
+    def test_02
+      foo = { :a=>1, :b=>2 }
+      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey!{|k|k.to_s}  )
+      assert_equal( { "a"=>1, "b"=>2 }, foo )
+    end
+
+    def test_03
+      foo = { :a=>1, :b=>2 }
+      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey(:to_s) )
+      assert_equal( { :a =>1, :b=>2 }, foo  )
+    end
+
+    def test_04
+      foo = { :a=>1, :b=>2 }
+      assert_equal( { "a"=>1, "b"=>2 }, foo.rekey!(:to_s) )
+      assert_equal( { "a"=>1, "b"=>2 }, foo )
+    end
+
+    def test_05
+      foo = { "a"=>1, "b"=>2 }
+      assert_equal( { :a=>1, :b=>2 }, foo.rekey! )
+      assert_equal( { :a=>1, :b=>2 }, foo )
+    end 
+
+  end
+
+=end
+

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

@@ -1,14 +1,17 @@
 
 class Hash
 
-  # Allows for reverse merging where its the keys in the calling hash that wins over those in the <tt>other_hash</tt>.
-  # This is particularly useful for initializing an incoming option hash with default values:
+  # Allows for reverse merging where its the keys in the
+  # calling hash that wins over those in the <tt>other_hash</tt>.
+  # This is particularly useful for initializing an incoming
+  # option hash with default values:
   #
   #   def setup(options = {})
   #     options.reverse_merge! :size => 25, :velocity => 10
   #   end
   #
-  # The default :size and :velocity is only set if the +options+ passed in doesn't already have those keys set.
+  # The default :size and :velocity is only set if the +options+
+  # passed in doesn't already have those keys set.
 
   def reverse_merge(other_hash)
     other_hash.merge(self)

data/lib/facets/core/inflect.rb

@@ -1,7 +1,6 @@
-#--
-# Inflect
+# = Inflect
 #
-# Copyright (c) 2005 Thomas Sawyer
+# == Copyright (c) 2005 Thomas Sawyer
 #
 # Ruby License
 #
@@ -12,12 +11,9 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 #
-#================================================================================
-# Revision History
-#================================================================================
-#  2005-10-25  trans
-#================================================================================
-#++
+# == Author(s)
+# 
+# * 7rans
 
 #:title: Inflect
 #
@@ -30,11 +26,6 @@
 #   :going.upcase         #=> :GOING
 #   :Arrow.capitlized?    #=> true
 #
-# = Author(s)
-#
-# * Thomas Sawyer
-# * (see Facets for corollary)
-#
 
 require 'facet/string/singular'
 require 'facet/string/plural'

data/lib/facets/core/integer/to_roman.rb

@@ -0,0 +1,20 @@
+#--
+# CREDIT William James
+#++
+
+class Integer
+
+  # Convert integer to roman numeral.
+
+  def to_roman
+    "I =1       V =5      X = 10       L = 50
+    C = 100    D = 500   M = 1000".
+    scan( / ([A-Z]) \s *= \s* (\d+) /x ).
+    map{|letter,val|  [ letter, val.to_i ] }.
+    sort_by{|a| -a.last}.
+    inject( [ "", self ] ){|roman, pair|
+      [ roman.first + pair.first * (roman.last / pair.last),
+        roman.last % pair.last ] }.
+    first
+  end
+end

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

@@ -1,9 +1,26 @@
+# = as.rb
 
-require 'facets/more/functor.rb'
+# LOG  2006-11-04  trans@gmail.com  Use own delegator instead of Functor.
+# LOG  2006-11-04  trans@gmail.com  Now #as can take a block.
 
 module Kernel
 
-  # Returns a Functor that allows one to call any parent method directly.
+  class As
+    # Privatize all methods except #binding an operators.
+    private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }
+
+    def initialize(subject, ancestor)
+      @subject = subject
+      @ancestor = ancestor
+    end
+
+    def method_missing(sym, *args, &blk)
+      @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
+    end
+  end
+
+  # Returns a As-functor that allows one to call any
+  # ancestor's method directly of the given object.
   #
   #   class A
   #     def x ; 1 ; end
@@ -18,38 +35,38 @@ module Kernel
   #   end
   #
   #   C.new.x  #=> 1
-  #
-  def __as__( klass=nil, &blk )
-    selfclass = Kernel.instance_method(:class).bind(self).call
-    klass ||= selfclass.superclass
-    if selfclass.ancestors.include?(klass)
-      Functor.new do |meth, *args|  # &blk|
-        klass.instance_method(meth).bind(self).call(*args) # ,&blk)
-      end
-    else
-      raise ArgumentError, "#{klass} is not an ancestor"
+
+  def as( ancestor, &blk )
+    @__as ||= {}
+    unless r = @__as[ancestor]
+      r = (@__as[ancestor] = As.new(self, ancestor))
     end
+    r.instance_eval(&blk) if block_given?
+    #yield(r) if block_given?
+    r
   end
+  #alias_method :__as__, :as
 
-  alias_method :as, :__as__
-
-=begin :nodoc:
-  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
+  def send_as( ancestor, sym, *args, &blk )
+    ancestor.instance_method(sym).bind(self).call(*args,&blk)
   end
-=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
 
 
 #  _____         _
@@ -73,7 +90,7 @@ end
     end
     class C < B
       def x; "C.x"; end
-      def y; as.x ; end
+      def y; as(B).x ; end
     end
 
     def setup

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

@@ -0,0 +1,14 @@
+
+module Kernel
+
+  # Convenience method to get simple console reply.
+
+  def ask( question, answers=nil )
+    print "#{question}"
+    print " [#{answers}] " if answers
+    until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
+    inp
+  end
+
+end
+

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

@@ -0,0 +1,10 @@
+
+module Kernel
+
+  # Defines an instance method within a class.
+
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+end

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

@@ -0,0 +1,21 @@
+# CREDIT David Heinemeier Hansson
+
+module Kernel
+
+  # Turns the current script into a daemon process
+  # that detaches from the console.
+  # It can be shut down with a TERM signal.
+
+  def daemonize
+    exit if fork                   # Parent exits, child continues.
+    Process.setsid                 # Become session leader.
+    exit if fork                   # Zap session leader. See [1].
+    Dir.chdir "/"                  # Release old working directory.
+    File.umask 0000                # Ensure sensible umask. Adjust as needed.
+    STDIN.reopen "/dev/null"       # Free file descriptors and
+    STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
+    STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
+    trap("TERM") { exit }
+  end
+
+end