facets 0.9.0 → 1.0.0

data/lib/facet/symbol/underscore.rb

@@ -1 +1,32 @@
-require 'nano/symbol/underscore.rb'
+
+require 'facet/string/underscore'
+
+class Symbol
+
+  def underscore
+    self.to_s.underscore.to_sym
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCSymbol < Test::Unit::TestCase
+
+    def test_underscore
+      assert_equal( :tis_a_test, :TisATest.underscore )
+    end
+
+  end
+
+=end

data/lib/facet/symbol/upcase.rb

@@ -1 +1,37 @@
-require 'nano/symbol/upcase.rb'
+
+require 'facet/string/upcase'
+
+class Symbol
+
+  def upcase
+    to_s.upcase.to_sym
+  end
+
+  def upcase?
+    to_s.upcase?
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCSymbol < Test::Unit::TestCase
+
+    def test_upcase?
+      assert( :TIS.upcase? )
+      assert( ! :Tis.upcase? )
+    end
+
+  end
+
+=end

data/lib/facet/time.rb

@@ -1 +1,7 @@
-require 'nano/time.rb'
+require 'nano/time/change'
+require 'nano/time/elapse'
+require 'nano/time/self/days_extrema'
+require 'nano/time/stamp'
+require 'nano/time/to_date'
+require 'nano/time/to_s'
+require 'nano/time/to_time'

data/lib/facet/time/change.rb

@@ -1 +1,51 @@
-require 'nano/time/change.rb'
+class Time
+
+  # Returns a new Time where one or more of the elements
+  # have been changed according to the +options+ parameter.
+  # The time options (hour, minute, sec, usec) reset
+  # cascadingly, so if only the hour is passed, then
+  # minute, sec, and usec is set to 0. If the hour and
+  #  minute is passed, then sec and usec is set to 0.
+
+  def change(options)
+    opts={}; options.each_pair{ |k,v| opts[k] = v.to_i }
+    self.class.send( self.utc? ? :utc : :local,
+      opts[:year]  || self.year,
+      opts[:month] || self.month,
+      opts[:day]   || self.day,
+      opts[:hour]  || self.hour,
+      opts[:min]   || (opts[:hour] ? 0 : self.min),
+      opts[:sec]   || ((opts[:hour] || opts[:min]) ? 0 : self.sec),
+      opts[:usec]  || ((opts[:hour] || opts[:min] || opts[:usec]) ? 0 : self.usec)
+    )
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'time'
+
+  class TCTime < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    def test_change
+      n = Time.now
+      n = n.change( :month=>4, :day=>20, :hour=>15, :min=>37 )
+      assert_equal( @t, n )
+    end
+
+  end
+
+=end

data/lib/facet/time/elapse.rb

@@ -1 +1,41 @@
-require 'nano/time/elapse.rb'
+
+class Time
+
+  # Tracks the elapse time of a code block.
+  #
+  #   Time.elapse { sleep 1 }  #=> 0.999188899993896
+  #
+  #--
+  # Credit goes to Hal Fulton.
+  #++
+  def self.elapse
+    raise "Need block" unless block_given?
+    t0 = Time.now.to_f
+    yield
+    Time.now.to_f - t0
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCTime < Test::Unit::TestCase
+
+    def test_elapse
+      t = Time.elapse { sleep 1 }
+      assert( (t > 0.9) && (t < 2.1 ))
+    end
+
+  end
+
+=end
+

data/lib/facet/time/self/days_extrema.rb

@@ -1 +1,22 @@
-require 'nano/time/self/days_extrema.rb'
+# This method calculates the days extrema given two time objects.
+# start time is the given time1 at 00:00:00
+# end time is the given time2 at 23:59:59:999
+#
+# Input:
+# - the two times (if only time1 is provided then you get an extrema
+#   of exactly one day extrema.
+#
+# Output:
+# - the time range. you can get the start/end times using
+#   range methods.
+#
+#--
+# Credit goes to George Moschovitis
+#++
+def Time.days_extrema(time1, time2=nil)
+  time2 = time1 if (not time2.valid? Time)
+  time2 = NEVER if (time2 <= time1)
+  start_time = Time.self.start_of_day(time1)
+  end_time = self.end_of_day(time2)
+  return (start_time..end_time)
+end

data/lib/facet/time/stamp.rb

@@ -1 +1,47 @@
-require 'nano/time/stamp.rb'
+
+class Time
+
+  def stamp( fmt = nil )
+    case fmt
+    when :db, :dbase, :database, :utc
+      strftime("%Y-%m-%d %H:%M:%S")
+    when :short
+      strftime("%e %b %H:%M")
+    when :long
+      strftime("%B %e, %Y %H:%M")
+    when :day1st, :dmYHM  # TODO generalize
+      strftime("%d-%m-%Y %H:%M")
+    when String
+      strftime( fmt ).strip
+    else
+      strftime("%a %b %d %H:%M:%S %Z %Y")
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'time'
+
+  class TCTime < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    def test_stamp
+      assert_equal( "Wed Apr 20 15:37:00 EDT 2005", @t.stamp )
+    end
+
+  end
+
+=end

data/lib/facet/time/to_date.rb

@@ -1 +1,37 @@
-require 'nano/time/to_date.rb'
+
+class Time
+
+  # Convert a Time to a Date. Time is a superset of Date.
+  # It is the year, month and day that are carried over.
+  def to_date
+    require 'date'
+    ::Date.new(year, month, day)
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'time'
+
+  class TCTime < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    def test_to_date
+      assert_instance_of( ::Date, @t.to_date )
+    end
+
+  end
+
+=end

data/lib/facet/time/to_s.rb

@@ -1 +1,33 @@
-require 'nano/time/to_s.rb'
+require 'facet/time/stamp'
+
+class Time
+  # Enhance #to_s by aliasing to #stamp.
+  alias_method :to_s, :stamp
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'time'
+
+  class TCTime < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    def test_to_s
+      assert_equal( "Wed Apr 20 15:37:00 EDT 2005", @t.to_s )
+    end
+
+  end
+
+=end

data/lib/facet/time/to_time.rb

@@ -1 +1,36 @@
-require 'nano/time/to_time.rb'
+
+class Time
+
+  # To be able to keep Dates and Times interchangeable
+  # on conversions.
+  def to_time
+    self
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'time'
+
+  class TCTime < Test::Unit::TestCase
+
+    def setup
+      @t = Time.parse('4/20/2005 15:37')
+    end
+
+    def test_to_time
+      assert_instance_of( ::Time, @t.to_time )
+    end
+
+  end
+
+=end

data/lib/facet/unboundmethod.rb

@@ -1 +1 @@
-require 'nano/unboundmethod.rb'
+require 'nano/unboundmethod/name'

data/lib/facet/unboundmethod/name.rb

@@ -1 +1,8 @@
-require 'nano/unboundmethod/name.rb'
+class UnboundMethod
+  # Return the name of the method.
+  # Is this already in 1.9+ ?
+  def name
+    i = to_s.rindex('#')
+    to_s.slice(i+1...-1)
+  end
+end

data/lib/facets.rb

@@ -1,8 +1,77 @@
 
-require 'nano/base.rb' unless $facets_without_base
+# These are the methods considered "base".
+# A method is deemed base if it is obvious,
+# simple, unobtrusive and/or widely useful.
+#
+# This list is still being refined.
+#
+# NOTE
+#
+# The #cmp methods are simply aliases for #<=>, they
+# are here b/c String.succ is not compataible
+# with it's own #<=> method. The #cmp method proves
+# an effective way of dealing with when needs be.
+
+# DEPRECATED Use Facets.require instead.
+#require 'kernel/require_facet'
+
+# Elementary
+require 'facet/comparable/cmp'
+require 'facet/string/cmp'
+require 'facet/nilclass/to_f'
+require 'facet/nilclass/to_h'
+require 'facet/binding/eval'
+require 'facet/binding/self'
+require 'facet/binding/caller'
+require 'facet/module/basename'
+require 'facet/proc/to_method'
+require 'facet/kernel/constant'
+require 'facet/kernel/called' # better name?
+require 'facet/symbol/to_proc'
+
+# Elementary (Know Thyself)
+require 'facet/hash/to_h'
+require 'facet/range/to_r'
+require 'facet/regexp/to_re'
+require 'facet/time/to_time'
+
+# "Minis" (Shorthands)
+require 'facet/module/is'
+require 'facet/kernel/fn'
+require 'facet/kernel/here'
+require 'facet/kernel/own' # better name?
+
+# Convenience
+require 'facet/array/to_h'
+require 'facet/enumerable/to_h'
+require 'facet/enumerable/collect_with_index'
+require 'facet/enumerable/each_slice'
+require 'facet/file/self/read_list'
+require 'facet/float/round_to'
+require 'facet/float/round_at'
+require 'facet/hash/slice'
+require 'facet/matchdata/match'
+require 'facet/matchdata/matchtree'
+require 'facet/string/blank'
+require 'facet/string/to_re'
+
+# New Features
+require 'facet/symbol/not'
+require 'facet/kernel/as'
+
+# This was a bad idea. Bye-bye.
+# extras
+#require 'rbconfig'
+#confdir = Config::CONFIG['sysconfdir']
+#extra_facets = File.join( confdir, 'facets', 'extra' )
+#if File.file?( extra_facets )
+#  extra_facets = File.read_list( extra_facets )
+#  extra_facets.each { |f| require f  }
+#end
+
 
 module Facets
-class << self
+  extend self
 
   # This simply subs terms for Ruby's operators
   # and removes any trailing ? ! or =.
@@ -13,8 +82,7 @@ class << self
     else
       dir, file = nil, name
     end
-    file = op_esc(file.strip) #.gsub(OperatorsRegexp) { OperatorsEscTable[$1] }
-    #file.chomp('?').chomp('!').chomp('=')
+    file = op_esc(file.strip)
     dir ? File.join( dir, file ) : file
   end
 
@@ -53,167 +121,80 @@ class << self
      "[]"   => "op_fetch"
   }
 
-  REQDIR = 'nano'
-  SETDIR = 'nano'
-
-  # Require methods for given class/module.
-  alias_method :_require, :require
-
-  def require( name )
-    #_require( "#{SETDIR}/#{name}" )
-    _require( File.join( 'facet', name ) )
-  end
+  CLASS_ANCESTORS = {
+    'array'         => ['enumerable','kernel'],
+    'binding'       => ['kernel'],
+    'class'         => ['module','kernel'],
+    'comparable'    => ['kernel'],
+    'continuation'  => ['kernel'],
+    'date'          => ['comparable','kernel'],
+    'dir'           => ['enumerable','kernel'],
+    'enumerable'    => ['kernel'],
+    'file'          => ['io','enumerable','kernel'],
+    'fileutils'     => ['kernel'],
+    'float'         => ['precision','numeric','comparable','kernel'],
+    'hash'          => ['enumerable','kernel'],
+    'integer'       => ['precision','numeric','comparable','kernel'],
+    'kernel'        => ['kernel'],
+    'logger'        => ['kernel'],
+    'matchdata'     => ['kernel'],
+    'module'        => ['kernel'],
+    'nilclass'      => ['kernel'],
+    'numeric'       => ['comparable','kernel'],
+    'ostruct'       => ['kernel'],
+    'pathname'      => ['kernel'],
+    'proc'          => ['kernel'],
+    'range'         => ['enumerable','kernel'],
+    'regexp'        => ['kernel'],
+    'string'        => ['enumerable','comparable','kernel'],
+    'symbol'        => ['kernel'],
+    'time'          => ['comparable','kernel'],
+    'unboundmethod' => ['kernel'],
+  }
 
-  #def require( klass, *meths )
-  #  provide_features( klass, *meths )
-  #end
-
-  def provide_features( klass, *meths )
-    classname = klass.to_s.downcase
-    loaded = true
-    meths.each do |m|
-      me = op_esc(m)
-      begin
-        r = _require( "#{REQDIR}/#{classname}/#{me}" )
-      rescue LoadError => e
-        if klass.ancestors[1]
-          classname = klass.ancestors[1].name.downcase
-          retry
-        else
+  METHDIR = "facet"
+
+  alias_method :require_facet, :require
+
+  def require( fname )
+    paths = fname.split('/')
+    klass = paths[0].downcase
+    if CLASS_ANCESTORS.key?( klass )
+      if paths.size > 1
+        klass = paths[0].downcase
+        ancestors = CLASS_ANCESTORS[ klass ] || []
+        paths[-1] = op_esc( paths[-1] )
+        begin
+          paths[0] = klass
+          require_facet( File.join( METHDIR, *paths ) )
+        rescue LoadError => e
+          klass = ancestors.shift
+          retry if klass
           raise e
         end
+      else
+        require_facet( File.join( METHDIR, fname ) )
       end
-      loaded = loaded && r
-    end
-    loaded
-  end
-
-  #--
-  # NOTE: The Fixnum constants can't be autoloaded.
-  # Nor can any pure method module. Fix?
-  #++
-
-  def autorequire
-    # built-in
-    autoload( 'CGI'        , 'cgi' )
-    autoload( 'FCGI'       , 'fcgi' )
-    autoload( 'FileUtils'  , 'fileutils' )
-    autoload( 'OpenStruct' , 'ostruct' )
-    autoload( 'YAML'       , 'yaml' )
-    # mega classes
-    autoload( 'ANSICode'       , 'mega/ansicode' )
-    autoload( 'BBCode'         , 'mega/bbcode' )
-    autoload( 'BinaryReader'   , 'mega/binaryreader' )
-    autoload( 'BasicObject'    , 'mega/basicobject' )
-    autoload( 'ByteOrder'      , 'mega/byteorder' )
-    autoload( 'ClassMethods'   , 'mega/classmethods' )
-    autoload( 'Constant'       , 'mega/constants' )
-    autoload( 'Coroutine'      , 'mega/coroutine' )
-    autoload( 'CrossCase'      , 'mega/crosscase' )
-    autoload( 'EnumerableArgs' , 'mega/enumerable_args' )
-    autoload( 'EnumeratedType' , 'mega/enumtype' )
-    autoload( 'FileList'       , 'mega/expirable' )
-    autoload( 'FloatString'    , 'mega/floatstring' )
-    autoload( 'Functor'        , 'mega/functor' )
-    autoload( 'HArray'         , 'mega/harray' )
-    autoload( 'Heap'           , 'mega/heap' )
-    autoload( 'Infinity'       , 'mega/infinity' )
-    autoload( 'Interval'       , 'mega/interval' )
-    autoload( 'IOReactor'      , 'mega/ioreactor' )
-    autoload( 'IORedirect'     , 'mega/ioredirect' )
-    autoload( 'LRUCache'       , 'mega/lru_cache' )
-    autoload( 'MethodProbe'    , 'mega/methodprobe' )
-    autoload( 'Multiton'       , 'mega/multiton' )
-    autoload( 'Nack'           , 'mega/nack' )
-    autoload( 'NilComparable'  , 'mega/nilcomparable' )
-    autoload( 'NotCopyable'    , 'mega/notcopyable' )
-    autoload( 'OpenStructable' , 'mega/ostructable' )
-    autoload( 'OrderedHash'    , 'mega/ohash' )
-    autoload( 'Dictionary'     , 'mega/dictionary' )  #?
-    autoload( 'Pool'           , 'mega/pool' )
-    autoload( 'PromoteSelf'    , 'mega/promote_self' )
-    autoload( 'Reference'      , 'mega/reference' )
-    autoload( 'Semaphore'      , 'mega/semaphore' )
-    autoload( 'StackParser'    , 'mega/stackparser' )
-    autoload( 'StaticHash'     , 'mega/statichash' )
-    autoload( 'SuperStruct'    , 'mega/superstruct' )
-    autoload( 'SyncHash'       , 'mega/synchash' )
-    autoload( 'SyncArray'      , 'mega/syncarray' )
-    autoload( 'SyncHash'       , 'mega/synchash' )
-    autoload( 'TagIterator'    , 'mega/tagiter' )
-    autoload( 'Timer'          , 'mega/timer' )
-    autoload( 'TracePoint'     , 'mega/tracepoint' )
-    autoload( 'Tuple'          , 'mega/tuple' )
-    autoload( 'Uninheritable'  , 'mega/uninheritable' )
-    autoload( 'Version'        , 'mega/version' )
-  end
-
-  alias  :autoload_classes :autorequire
-  alias  :autoload_modules :autorequire
-
-end
-end
-
-
-class Module
-
-  # Generalize method aquiring features from a 
-  # providing module. You can use this with
-  # Facets. Instead of
-  #
-  #   require 'facet/string/humanize'
-  #   require 'facet/string/last'
-  #
-  # do
-  #
-  #   String.use Facets, 'humanize', 'last='
-  #
-  def use( package, *meths )
-    if String === package or Symbol === package
-      package = constant(package)
+    else
+      require_facet( File.join( METHDIR, fname ) )
     end
-    package.provide_features( self, *meths )
   end
 
 end
 
 
-
-
-# scrap
-
-# module Kernel
-#
-#   loc = [
-#     File.join( File.dirname(__FILE__), 'facets/ext' ),
-#     File.join( File.dirname(__FILE__), 'facets/set' ),
-#     File.join( File.dirname(__FILE__), 'facets/set/general' ),
-#     File.join( File.dirname(__FILE__), 'facets/set/special' ),
-#     File.join( File.dirname(__FILE__), 'facets' )
-#   ]
-#
-#   alias_method :require_without_facets, :require #req = instance_method(:require)
-#
-#   define_method( :require ) do |req, *args|
-#
-#     loaded = false
-#     success = false
+# Override Kernel require method to reroute Facet requires.
 #
-#     if md = %r{^(facets|facet|nano)[\/\\]}.match( req )
-#       name = FacetSystem.op_esc_path( md.post_match ) + '.rb'
-#       dir = loc.find{ |d| File.file?( File.join(d,name) ) }
-#       if dir
-#         loaded = require_without_facets( File.join( dir,name ), *args )
-#         success = true
-#       end
-#     end
+#module Kernel
 #
-#     unless success
-#       #req.bind(self).call( name, *args )
-#       loaded = require_without_facets( req, *args )
-#     end
+#  alias_method :require_facetless, :require
 #
-#     loaded
-#   end
+#  def require( fname )
+#    if /^(facet|facets|nano)[\/\\]/ =~ fname
+#      Facets.require($')
+#    else
+#      require_facetless( fname )
+#    end
+#  end
 #
-# end
+#end