facets 2.4.3 → 2.4.4

data/lib/core/facets/time/set.rb

@@ -1 +1,21 @@
-require 'facets/time/change'
+class Time
+
+  # Like change but does not reset earlier times.
+  #
+  # NOTE: It would be better, probably if this were called "change".
+  #       and that #change were called "reset".
+  #
+  def set(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]   || self.min,
+      opts[:sec]   || self.sec,
+      opts[:usec]  || self.usec
+    )
+  end
+
+end

data/lib/core/facets/time/stamp.rb

@@ -6,7 +6,9 @@ class Time
       :dbase   => "%Y-%m-%d %H:%M:%S",
       :datbase => "%Y-%m-%d %H:%M:%S",
       :utc     => "%Y-%m-%d %H:%M:%S",
+      :number  => "%Y%m%d%H%M%S",
       :short   => "%d %b %H:%M",
+      :time    => "%H:%M",
       :long    => "%B %d, %Y %H:%M",
       :day1st  => "%d-%m-%Y %H:%M",
       :dmYHM   => "%d-%m-%Y %H:%M",
@@ -38,9 +40,5 @@ class Time
     strftime(fmt).strip
   end
 
-  # DEPRECATED.
-  # Enhance #to_s by aliasing to #stamp.
-  #alias_method :to_s, :stamp
-
 end
 

data/lib/core/facets/time/to_time.rb

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+class Time
 
-  class Time
+  unless defined? to_time #1.9
 
     # To be able to keep Dates and Times interchangeable
     # on conversions.
@@ -9,6 +9,12 @@ unless (RUBY_VERSION[0,3] == '1.9')
       getlocal 
     end
 
+    # A method to keep Time, Date and DateTime instances interchangeable on conversions.
+    # In this case, it simply returns +self+.
+    #def to_time
+    #  self
+    #end
+
   end
 
 end

data/lib/core/facets/unboundmethod.rb

@@ -1,3 +1,6 @@
-require 'facets/unboundmethod/arguments'
-require 'facets/unboundmethod/name'
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
 

data/lib/lore/facets/basicobject.rb

@@ -1,263 +1,14 @@
-# = BasicObject
-#
-# BasicObject provides an abstract base class with no predefined
-# methods, except for <tt>respond_to?</tt>, any method starting in
-# <tt>\_\_</tt> (two underscore, like <tt>\_\_id__</tt>) as well as
-# any method starting with <tt>instance_</ttr>.
-#
-# BasicObject is useful as a base class when writing classes that
-# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-#
-# The patterns used to reserve methods are:
-#
-#    /^__/, /^instance/, /^object/, /\?$/, /^\W$/,
-#    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null', 'as'
-#
-# By default these are the reserved methods:
-#
-#   == __id__ __self__ __send__ as clone dup eql? equal? frozen?
-#   initialize inspect instance_eval instance_of? instance_variable_get
-#   instance_variable_set instance_variables is_a? kind_of? nil? null object_class
-#   respond_to? tainted?
-#
-# In practice only 'as', 'clone', 'dup' and 'null' have much chance of name clash.
-# So be especially aware of these four. All the rest either begin with a '__',
-# end in a '?' mark or start with the word 'instance' or 'object'.
-#
-# The special method #object_self allows access to the underlying object via a
-# specialized Functor-style class access via as(Object). This binds the
-# actual self to the subsequently called methods of Object instancea methods.
-# So even though a method may no longer be defined for BasicObject it can still
-# be called via this interface.
-#
-#   class A < BasicObject
-#   end
-#
-#   a.object_self.class  #=> A
-#   a.class              #=> NoMethodError
-#
-# Note that #object_self used to be called __self__. Also provided is #object_class.
-#
-# == Authors
-#
-# * Jim Weirich
-# * Thomas Sawyer
-#
-# == History
-#
-#   Thanks to Jim Weirich for BlankSlate Copyright (c) 2004 by Jim Weirich,
-#   on which BasicObject is based.
-#
-# == Todo
-#
-# * Might be nice it there were a factory method to alter which methods
-#   were excluded. But probably too dangerous.
-#
-# == Copying
-#
-# Copyright (c) 2005 Thomas Sawyer, Jim Weirich
-#
-# 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.
+# Facets' old BasicObject has been replaced totally replaced by 
+# Jim Weirich's BlankSlate. Since Ruby 1.9 has a BasicObject class
+# this  will of course be deprecated when 1.9 goes mainstream.
 
-require 'facets/kernel/object_class'
-require 'facets/kernel/as'
+unless defined? ::BasicObject  # just in case it already exists!
 
-# = BasicObject
-#
-# BasicObject provides an abstract base class with no predefined
-# methods, except for <tt>respond_to?</tt>, any method starting in
-# <tt>\_\_</tt> (two underscore, like <tt>\_\_id__</tt>) as well as
-# any method starting with <tt>instance_</ttr>.
-#
-# BasicObject is useful as a base class when writing classes that
-# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-#
-# The patterns used to reserve methods are:
-#
-#    /^__/, /^instance/, /^object/, /\?$/, /^\W$/,
-#    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null', 'as'
-#
-# By default these are the reserved methods:
-#
-#   == __id__ __self__ __send__ as clone dup eql? equal? frozen?
-#   initialize inspect instance_eval instance_of? instance_variable_get
-#   instance_variable_set instance_variables is_a? kind_of? nil? null object_class
-#   respond_to? tainted?
-#
-# In practice only 'as', 'clone', 'dup' and 'null' have much chance of name clash.
-# So be especially aware of these four. All the rest either begin with a '__',
-# end in a '?' mark or start with the word 'instance' or 'object'.
-#
-# The special method #object_self allows access to the underlying object via a
-# specialized Functor-style class access via as(Object). This binds the
-# actual self to the subsequently called methods of Object instancea methods.
-# So even though a method may no longer be defined for BasicObject it can still
-# be called via this interface.
-#
-#   class A < BasicObject
-#   end
-#
-#   a.object_self.class  #=> A
-#   a.class              #=> NoMethodError
-#
-# Note that #object_self used to be called __self__. Also provided is #object_class.
-#
-# Since Ruby is very dynamic, methods added to the ancestors of
-# BasicObject <em>after BasicObject is defined</em> will show up in the
-# list of available BasicObject methods.  We handle this by defining
-# hooks in Object, Kernel and Module that will hide any defined.
+  require 'facets/blankslate'
 
-class BasicObject
+  # ActiveSupport compatiable version of BasicObject
+  # if not Ruby 1.9+ uses Jim Weirich's BlankSlate.
+  BasicObject = BlankSlate
 
-  # Returns the Self functor class, which can then be used to
-  # call Kernel/Object methods on the current object.
-
-  def object_self
-    @__object_self__ ||= As.new(self, ::Object)
-  end
-  alias :__self__ :object_self
-
-#--
-  # The Self class allows one to get access the hidden Object/Kernel methods.
-  # It is essentially a specialized Functor which binds an Object/Kernel
-  # method to the current object for the current call.
-
-  #class Self < self
-  #  def initialize(obj, as=nil)
-  #    @obj = obj
-  #    @as = as || ::Object
-  #  end
-  #  def method_missing(meth, *args, &blk)
-  #    @as.instance_method(meth).bind(@obj).call(*args, &blk)
-  #  end
-  #end
-
-  # This method is like #__self__, but allows any ancestor
-  # to act on behalf of self, not just Object.
-  #
-  #def __as__( ancestor )
-  #  Self.new( self, ancestor )
-  #end
-  #alias_method :as, :__as__
-
-  # Shadow some other important methods.
-
-  #alias_method :__eval__, :eval
-  #alias_method :__method__, :method
-#++
-
-  # Methods not to get rid of as they are either too important, or
-  # they are not likely to get in the way (such as methods ending in '?').
-  #
-  # In Ruby 1.9 BasicObject has only these methods:
-  # [ /^__/, "funcall", "send", "respond_to?", "equal?", "==", "object_id" ]
-  #
-  # NOTE The absolute bare minimum is EXCLUDE = /^(__|instance_eval$)/.
-  # But in most cases you'll want a few extra methods like #dup too.
-  #
-  #--
-  # TODO In the future it might be nice to allow some selectability
-  # in these via a factory method.
-  #++
-
-  EXCLUDE = [
-    /^__/, /^instance_/, /^object_/, /\?$/, /^\W$/,
-    'initialize', 'initialize_copy', 'inspect', 'dup', 'clone', 'null', 'as'
-  ]
-
-  # Undef unwanted method as long as it doesn't match anything in the EXCLUDE list.
-
-  def self.hide(name)
-    #if instance_methods.include?(name.to_s) and name !~ EXCLUDE #/^(#{EXCLUDE.join('|')})/
-    #if name !~ EXCLUDE and
-    case name
-    when *EXCLUDE
-      # do nothing
-    else
-      #if ( public_instance_methods.include?(name.to_s) or
-      #     private_instance_methods.include?(name.to_s) or
-      #     protected_instance_methods.include?(name.to_s)
-      #   )
-        undef_method name rescue nil
-      #end
-    end
-  end
-
-  # remove all methods
-
-  public_instance_methods(true).each { |m| hide(m) }
-  private_instance_methods(true).each { |m| hide(m) }
-  protected_instance_methods(true).each { |m| hide(m) }
-
-#--
-  # If the method isn't defined and has the form '__method__'
-  # then try sending 'method' to self-as-Object. Remember
-  # this will not have any effect if you override it!
-
-  #def method_missing( sym, *args, &blk )
-  #  if md = /^__(.+)__$/.match( sym.to_s )
-  #    as(Object).__send__( md[1], *args, &blk )
-  #  else
-  #    super
-  #  end
-  #end
-#++
-
-end
-
-module Kernel #:nodoc:
-  class << self
-    madded = method(:method_added)
-    define_method(:method_added) do |name|
-      r = madded.call(name)
-      return r if self != Kernel
-      BasicObject.hide(name)
-      r
-    end
-  end
-end
-
-# See Kernel callback.
-
-class Object #:nodoc:
-  class << self
-    madded = method(:method_added)
-    define_method(:method_added) do |name|
-      r = madded.call(name)
-      return r if self != Object
-      BasicObject.hide(name)
-      r
-    end
-  end
-end
-
-# Also, modules included into Object need to be scanned and have their
-# instance methods removed from blank slate.  In theory, modules
-# included into Kernel would have to be removed as well, but a
-# "feature" of Ruby prevents late includes into modules from being
-# exposed in the first place.
-=begin
-class Module
-  if method_defined?(:append_features)
-    mappended = method(:append_features)
-  else
-    mappended = nil
-  end
-  define_method(:append_features) do |mod|
-    r = mappended.call(mod) if mappended
-    return r if mod != Object
-    public_instance_methods(true).each { |name| BasicObject.hide(name) }
-    private_instance_methods(true).each { |name| BasicObject.hide(name) }
-    public_instance_methods(true).each { |name| BasicObject.hide(name) }
-    r
-  end
 end
-=end
 

data/lib/lore/facets/cgi.rb

@@ -7,7 +7,7 @@ require 'cgi'
 
 # = CGI Extensions
 
-module CGI
+class CGI
 
   # Create an hidden input field through which an object can can be marshalled.
   # This makes it very easy to pass from data betwenn requests.

data/lib/lore/facets/date.rb

@@ -1,57 +1,85 @@
-# = Date Extended
-#
-# Ruby's standard Date class with a few extensions.
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-#   Copyright (c) 2004 Thomas Sawyer
+require 'date'
+require 'facets/time/stamp'
+
+# = Date
 #
-#   Ruby License
+# This new version of Date extension has been largely improved by
+# porting some of the methods used by ActiveSupport. The old version
+# already had much in common with the Active Support library, so it
+# was decided to take it a step further in that direction for the
+# sake of interoparability.
 #
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
+# Hopefully most of these methods will find there way into Ruby's
+# own standard library eventually.
 #
-#   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.
-
-require 'date'
-require 'parsedate' # needed for String#to_date
+# The biggest difference with ActiveSupport is the lack of many
+# of the "English-esque" methods, and that we use #stamp with
+# Date::FORMAT, instead of #to_formmated_s with Date::DATE_FORMATS.
+# We do not override the standard #to_s method like ActiveSupport does.
 
 class Date
 
-  # To be able to keep Dates and Times
-  # interchangeable on conversions.
+  FORMAT = {
+    :short        => "%e %b",
+    :long         => "%B %e, %Y",
+    :db           => "%Y-%m-%d",
+    :number       => "%Y%m%d",
+    :rfc822       => "%e %b %Y",
+    :default      => "%Y-%m-%d",
+    nil           => "%Y-%m-%d"
+  }
+
+  # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
+  def self.yesterday
+    ::Date.today.yesterday
+  end
+  
+  # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
+  def self.tomorrow
+    ::Date.today.tomorrow
+  end
+  
+  # Returns Time.zone.today when config.time_zone is set, otherwise just returns Date.today.
+  def self.current
+    ::Time.zone_default ? ::Time.zone.today : ::Date.today
+  end
+
+  # A method to keep Time, Date and DateTime instances interchangeable
+  # on conversions. In this case, it simply returns +self+.
   def to_date
     self
-  end
+  end if RUBY_VERSION < '1.9'
 
-  # Convert Date to Time.
+  # Converts a Date instance to a DateTime, where the time is set to the beginning of the day
+  # and UTC offset is set to 0.
   #
-  def to_time(form = :local)
+  # ==== Example:
+  #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
+  #
+  #   date.to_datetime               # => Sat, 10 Nov 2007 00:00:00 0000
+  def to_datetime
+    ::DateTime.civil(year, month, day, 0, 0, 0, 0)
+  end if RUBY_VERSION < '1.9'
+
+  # Converts a Date instance to a Time, where the time is set to the beginning of the day.
+  # The timezone can be either :local or :utc (default :local).
+  #
+  #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
+  #
+  #   date.to_time                   # => Sat Nov 10 00:00:00 0800 2007
+  #   date.to_time(:local)           # => Sat Nov 10 00:00:00 0800 2007
+  #
+  #   date.to_time(:utc)             # => Sat Nov 10 00:00:00 UTC 2007
+  #
+  def to_time(form=:local)
     ::Time.send(form, year, month, day)
+    #::Time.send("#{form}_time", year, month, day)
   end
 
-  # An enhanched #to_s method that cane take an optional
-  # format flag of :short or :long.
-  def stamp(format = nil)
-    case format
-    when :short
-      strftime("%e %b").strip
-    when :long
-      strftime("%B %e, %Y").strip
-    else
-      strftime("%Y-%m-%d")  # standard to_s
-    end
+  def xmlschema
+    to_time.xmlschema
   end
 
-  # Enhance #to_s by aliasing to #stamp.
-  alias_method( :to_s, :stamp )
-
   # Returns the number of days in the date's month.
   #
   #   Date.new(2004,2).days_in_month #=> 28
@@ -74,16 +102,294 @@ class Date
     MONTHNAMES[self.month]
   end
 
+  # Convert to a formatted string. See DATE_FORMATS for predefined formats.
+  #
+  # This method is aliased to <tt>to_s</tt>.
+  #
+  # ==== Examples:
+  #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
+  #
+  #   date.stamp(:db)            # => "2007-11-10"
+  #   date.stamp(:short)         # => "10 Nov"
+  #   date.stamp(:long)          # => "November 10, 2007"
+  #   date.stamp(:rfc822)        # => "10 Nov 2007"
+  #
+  # == Adding your own formats to stamp
+  # You can add your own formats to the Date::FORMAT hash.
+  # Use the format name as the hash key and a strftime string
+  # as the value. Eg.
+  #
+  #   Date::FORMAT[:month_and_year] = "%B %Y"
+  #
+  def stamp(format=:default)
+    if formatter = FORMAT[format]
+      strftime(formatter)
+    else
+      to_s
+    end
+  end
+
+  # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
+  #def inspect
+  #  strftime("%a, %d %b %Y")
+  #end
+
+  # Provides precise Date calculations for years, months, and days.  The +options+ parameter takes a hash with 
+  # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
+  def advance(options)
+    d = self
+    d = d >> options.delete(:years) * 12 if options[:years]
+    d = d >> options.delete(:months)     if options[:months]
+    d = d +  options.delete(:weeks) * 7  if options[:weeks]
+    d = d +  options.delete(:days)       if options[:days]
+    d
+  end
+
+  # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
+  #
+  # Examples:
+  #
+  #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
+  #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
+  def change(options)
+    ::Date.new(
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || self.day
+    )
+  end
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  # and then subtracts the specified number of seconds
+  def ago(seconds)
+    to_time.since(-seconds)
+  end
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  # and then adds the specified number of seconds
+  def since(seconds)
+    to_time.since(seconds)
+  end
+  alias :in :since
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  def beginning_of_day
+    to_time
+  end
+  alias :midnight :beginning_of_day
+
+  # Convenience method which returns a new Date/DateTime representing the time 1 day ago
+  def yesterday
+    self - 1
+  end
+
+  # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
+  def tomorrow
+    self + 1
+  end
+
 end
 
-class String
 
-  # Parse data from string.
+class DateTime
+
   #
-  #  CREDIT: Trans
+  def self.local_offset
+    ::Time.local(2007).utc_offset.to_r / 86400
+  end
 
+  # Converts self to a Ruby Date object; time portion is discarded
+  def to_date
+    ::Date.new(year, month, day)
+  end
+
+  # Attempts to convert self to a Ruby Time object; returns self if
+  # out of range of Ruby Time class, If self has an offset other than 0,
+  # self will just be returned unaltered, since there's no clean way
+  # to map it to a Time
+  def to_time
+    self.offset == 0 ? ::Time.utc_time(year, month, day, hour, min, sec) : self
+  end
+
+  # To be able to keep Times, Dates and DateTimes interchangeable on conversions
+  def to_datetime
+    self
+  end
+
+  # Convert to a formatted string. See Time::FORMAT for predefined formats.
+  # 
+  # This method is aliased to <tt>to_s</tt>.
+  # 
+  # === Examples:
+  #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
+  # 
+  #   datetime.stamp(:db)            # => "2007-12-04 00:00:00"
+  #   datetime.stamp(:db)            # => "2007-12-04 00:00:00"
+  #   datetime.stamp(:number)        # => "20071204000000"
+  #   datetime.stamp(:short)         # => "04 Dec 00:00"
+  #   datetime.stamp(:long)          # => "December 04, 2007 00:00"
+  #   datetime.stamp(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
+  #
+  # == Adding your own datetime formats to stamp
+  # DateTime formats are shared with Time. You can add your own to the
+  # Time::FORMAT hash. Use the format name as the hash key and
+  # a strftime string as the value. Eg.
+  #
+  #   Time::FORMAT[:month_and_year] = "%B %Y"
+  #
+  def stamp(format=:default)
+    if formatter = ::Time::FORMAT[format]
+      strftime(formatter)
+    else
+      to_s
+    end
+  end
+
+  # Seconds since midnight: DateTime.now.seconds_since_midnight
+  def seconds_since_midnight
+    self.sec + (self.min * 60) + (self.hour * 3600)
+  end
+
+  # Returns a new DateTime where one or more of the elements have been
+  # changed according to the +options+ parameter. The time options
+  # (hour, minute, sec) reset cascadingly, so if only the hour is 
+  # passed, then minute and sec is set to 0. If the hour and
+  # minute is passed, then sec is set to 0.
+  def change(options)
+    ::DateTime.civil(
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || self.day,
+      options[:hour]  || self.hour,
+      options[:min]   || (options[:hour] ? 0 : self.min),
+      options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+      options[:offset]  || self.offset,
+      options[:start]  || self.start
+    )
+  end
+
+  # Uses Date to provide precise Time calculations for years, months, and days.
+  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+  # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  def advance(options)
+    d = to_date.advance(options)
+    datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+    seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
+    seconds_to_advance == 0 ? datetime_advanced_by_date : datetime_advanced_by_date.since(seconds_to_advance)
+  end
+
+  # Returns a new DateTime representing the time a number of seconds ago
+  # Do not use this method in combination with x.months, use months_ago instead!
+  def ago(seconds)
+    self.since(-seconds)
+  end
+
+  # Returns a new DateTime representing the time a number of seconds since the instance time
+  # Do not use this method in combination with x.months, use months_since instead!
+  def since(seconds)
+    self + Rational(seconds.round, 86400)
+  end
+  alias :in :since
+
+  # Returns a new DateTime representing the start of the day (0:00)
+  def beginning_of_day
+    change(:hour => 0)
+  end
+  alias :midnight :beginning_of_day
+
+  # Returns a new DateTime representing the end of the day (23:59:59)
+  def end_of_day
+    change(:hour => 23, :min => 59, :sec => 59)
+  end
+  
+  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0
+  #
+  # Example:
+  #
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))       # => Mon, 21 Feb 2005 10:11:12 -0600
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc   # => Mon, 21 Feb 2005 16:11:12 +0000
+  def utc
+    new_offset(0)
+  end
+  alias_method :getutc, :utc
+  
+  # Returns true if offset == 0
+  def utc?
+    offset == 0
+  end
+  
+  # Returns the offset value in seconds
+  def utc_offset
+    (offset * 86400).to_i
+  end
+
+  # Converts datetime to an appropriate format for use in XML
+  def xmlschema
+    strftime("%Y-%m-%dT%H:%M:%S%Z")
+  end if RUBY_VERSION < '1.9'
+
+  # Converts self to a floating-point number of seconds since the Unix epoch 
+  def to_f
+    days_since_unix_epoch = self - ::DateTime.civil(1970)
+    (days_since_unix_epoch * 86_400).to_f
+  end
+
+end
+
+
+class Time
+
+  public :to_date
+  public :to_datetime
+
+  # Converts a Time object to a Date, dropping hour, minute, and second precision.
+  #
+  #   my_time = Time.now  # => Mon Nov 12 22:59:51 -0500 2007
+  #   my_time.to_date     # => Mon, 12 Nov 2007
+  #
+  #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
+  #   your_time.to_date                                 # => Tue, 13 Jan 2009
+  def to_date
+    ::Date.new(year, month, day)
+  end
+
+  #  # 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' # just in case
+  #    jd = Date.__send__(:civil_to_jd, year, mon, mday, Date::ITALY)
+  #    Date.new!(Date.__send__(:jd_to_ajd, jd, 0, 0), 0, Date::ITALY)
+  #  end
+
+
+  # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
+  #
+  #   my_time = Time.now    # => Mon Nov 12 23:04:21 -0500 2007
+  #   my_time.to_datetime   # => Mon, 12 Nov 2007 23:04:21 -0500
+  #
+  #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
+  #   your_time.to_datetime                             # => Tue, 13 Jan 2009 13:13:03 -0500
+  def to_datetime
+    ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
+  end
+
+end
+
+
+class String
+
+  # Convert string to DateTime.
+  def to_datetime
+    date = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 }
+    ::DateTime.civil(*date)
+  end
+
+  # Parse data from string.
   def to_date
-    ::Date::civil(*ParseDate.parsedate(self)[0..2])
+    #::Date::civil(*ParseDate.parsedate(self)[0..2])
+    ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
   end
 
 end