facets 1.0.2 → 1.0.3

data/packages/core/lib/facet/time.rb

@@ -0,0 +1,7 @@
+require 'facet/time/change'
+require 'facet/time/elapse'
+require 'facet/time/self/days_extrema'
+require 'facet/time/stamp'
+require 'facet/time/to_date'
+require 'facet/time/to_s'
+require 'facet/time/to_time'

data/packages/core/lib/facet/time/change.rb

@@ -0,0 +1,51 @@
+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/2006 15:37')
+    end
+
+    def test_change
+      n = Time.now
+      n = n.change( :month=>4, :day=>20, :hour=>15, :min=>37, :year=>2006 )
+      assert_equal( @t, n )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/time/elapse.rb

@@ -0,0 +1,41 @@
+
+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/packages/core/lib/facet/time/self/days_extrema.rb

@@ -0,0 +1,22 @@
+# 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/packages/core/lib/facet/time/self/stamp.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/time/stamp'

data/packages/core/lib/facet/time/stamp.rb

@@ -0,0 +1,51 @@
+
+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
+
+  def self.stamp(*args)
+    now.stamp(*args)
+  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/packages/core/lib/facet/time/to_date.rb

@@ -0,0 +1,37 @@
+
+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/packages/core/lib/facet/time/to_s.rb

@@ -0,0 +1,33 @@
+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/packages/core/lib/facet/time/to_time.rb

@@ -0,0 +1,36 @@
+
+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/packages/core/lib/facet/unboundmethod.rb

@@ -0,0 +1 @@
+require 'facet/unboundmethod/name'

data/packages/core/lib/facet/unboundmethod/name.rb

@@ -0,0 +1,8 @@
+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/packages/core/lib/facets.rb

@@ -0,0 +1,200 @@
+
+# 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
+  extend self
+
+  # This simply subs terms for Ruby's operators
+  # and removes any trailing ? ! or =.
+  def op_esc_path( name )
+    ri = name.rindex('/')
+    if ri
+      dir, file = name[0...ri], name[ri+1..-1]
+    else
+      dir, file = nil, name
+    end
+    file = op_esc(file.strip)
+    dir ? File.join( dir, file ) : file
+  end
+
+  def op_esc( str )
+    str = str.to_s.chomp('.rb')
+    str = str.strip.gsub(OPERATORS_REGEXP){ OPERATORS_ESCAPE[$1] }
+    str.chomp('?').chomp('!').chomp('=')
+  end
+
+  OPERATORS = %w{ +@ -@ + - ** * / % ~ <=> << >> < > === == =~ <= >= | & ^ []= [] }
+  OPERATORS_REGEXP = Regexp.new( '(' << OPERATORS.collect{ |k| Regexp.escape(k) }.join('|') << ')' )
+  OPERATORS_ESCAPE = {
+     "+@"   => "op_plus_self",
+     "-@"   => "op_minus_self",
+     "+"    => "op_plus",
+     "-"    => "op_minus",
+     "**"   => "op_pow",
+     "*"    => "op_mul",
+     "/"    => "op_div",
+     "%"    => "op_mod",
+     "~"    => "op_tilde",
+     "<=>"  => "op_cmp",
+     "<<"   => "op_lshift",
+     ">>"   => "op_rshift",
+     "<"    => "op_lt",
+     ">"    => "op_gt",
+     "==="  => "op_case_eq",
+     "=="   => "op_equal",
+     "=~"   => "op_apply",
+     "<="   => "op_lt_eq",
+     ">="   => "op_gt_eq",
+     "|"    => "op_or",
+     "&"    => "op_and",
+     "^"    => "op_xor",
+     "[]="  => "op_store",
+     "[]"   => "op_fetch"
+  }
+
+  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'],
+  }
+
+  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
+    else
+      require_facet( File.join( METHDIR, fname ) )
+    end
+  end
+
+end
+
+
+# Override Kernel require method to reroute Facet requires.
+#
+#module Kernel
+#
+#  alias_method :require_facetless, :require
+#
+#  def require( fname )
+#    if /^(facet|facets|nano)[\/\\]/ =~ fname
+#      Facets.require($')
+#    else
+#      require_facetless( fname )
+#    end
+#  end
+#
+#end