Index: TimeOps.cs
===================================================================
--- TimeOps.cs	(revision 93)
+++ TimeOps.cs	(working copy)
@@ -15,30 +15,274 @@
 
 using System;
 using System.Collections.Generic;
-using System.Runtime.InteropServices;
 using System.Text;
+
 using Microsoft.Scripting;
+using Microsoft.Scripting.Math;
+using Microsoft.Scripting.Actions;
+
 using Ruby.Runtime;
+using System.Diagnostics;
+using Microsoft.Scripting.Utils;
+using Ruby.Builtins;
 
 namespace Ruby.Builtins {
     [RubyClass("Time", Extends = typeof(DateTime))]
     [Includes(typeof(Comparable))]
     public static class TimeOps {
+        readonly static DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); //January 1, 1970 00:00 UTC
 
         [RubyConstructor]
+        public static DateTime Create(){
+            return DateTime.Now;
+        }
+
+        [RubyConstructor]
+        public static DateTime Create(DateTime other){
+            return new DateTime(other.Ticks, other.Kind);
+        }
+
+        #region "Singleton Methods"
+
+        [RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime Create(Object self, DateTime other){
+            return new DateTime(other.Ticks, other.Kind);
+        }
+
+        [RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime Create(object self, long seconds){
+            return epoch.ToLocalTime().AddSeconds(seconds);
+        }
+
+        [RubyMethod("at", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime Create(object self, long seconds, long microseconds){
+            long ticks = epoch.ToLocalTime().Ticks + secondsToTicks(seconds) + microsecondsToTicks(microseconds);
+            return new DateTime(ticks);
+        }
+
+        private static long microsecondsToTicks(long microseconds){
+            return microseconds * 10;
+        }
+
+        private static long secondsToTicks(long seconds){
+            return seconds * 10000000;
+        }
+
         [RubyMethod("now", RubyMethodAttributes.PublicSingleton)]
         public static DateTime CreateTime(object self) {
             return DateTime.Now;
         }
 
-        [RubyMethod("<=>")]
-        public static object Compare(DateTime self, object other) {
-            return null;
+        [RubyMethod("today", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime Today(object self){
+            return DateTime.Today;
         }
 
-        [RubyMethod("<=>")]
-        public static int Compare(DateTime self, DateTime other) {
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year){
+            return new DateTime(Year, 1, 1);
+        }
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year, int Month){
+            return new DateTime(Year, Month, 1);
+        }
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year, int Month, int Day){
+            return new DateTime(Year, Month, Day);
+        }
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year, int Month, int Day, int Hour){
+            return new DateTime(Year, Month, Day, 0, 0, 0);
+        }
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year, int Month, int Day, int Hour, int Minute){
+            return new DateTime(Year, Month, Day, Hour, Minute, 0);
+        }
+        [RubyMethod("mktime", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("local", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createLocalTime(object self, int Year, int Month, int Day, int Hour, int Minute, int Second){
+            return new DateTime(Year, Month, Day, Hour, Minute, Second);
+        }
+
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year){
+            return new DateTime(Year, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        }
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year, int Month){
+            return new DateTime(Year, Month, 1, 0, 0, 0, DateTimeKind.Utc);
+        }
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year, int Month, int Day){
+            return new DateTime(Year, Month, Day, 0, 0, 0, DateTimeKind.Utc);
+        }
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year, int Month, int Day, int Hour){
+            return new DateTime(Year, Month, Day, 0, 0, 0);
+        }
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year, int Month, int Day, int Hour, int Minute){
+            return new DateTime(Year, Month, Day, Hour, Minute, 0);
+        }
+        [RubyMethod("utc", RubyMethodAttributes.PublicSingleton)]
+        [RubyMethod("gm", RubyMethodAttributes.PublicSingleton)]
+        public static DateTime createGmtTime(object self, int Year, int Month, int Day, int Hour, int Minute, int Second){
+            return new DateTime(Year, Month, Day, Hour, Minute, Second);
+        }
+
+        #endregion "Singleton Methods"
+
+        [RubyMethod("+", RubyMethodAttributes.PublicInstance)]
+        public static DateTime addSeconds(DateTime self, double seconds){
+            return self.AddSeconds(seconds);
+        }
+
+        [RubyMethod("+", RubyMethodAttributes.PublicInstance)]
+        public static DateTime addTime(DateTime self, DateTime other){
+            return new DateTime(self.Ticks + (other.Ticks - epoch.Ticks));
+        }
+
+        [RubyMethod("-", RubyMethodAttributes.PublicInstance)]
+        public static DateTime SubtractSeconds(DateTime self, double seconds){
+            return self.AddSeconds(-1 * seconds);
+        }
+
+        [RubyMethod("-", RubyMethodAttributes.PublicInstance)]
+        public static DateTime SubtractTime(DateTime self, DateTime other){
+            return new DateTime(self.Ticks - (other.Ticks - epoch.Ticks));
+        }
+
+        [RubyMethod("<=>", RubyMethodAttributes.PublicInstance)]
+        public static int CompareSeconds(DateTime self, double seconds){
+            DateTime other = epoch.AddSeconds(seconds);
             return self.CompareTo(other);
         }
+
+        [RubyMethod("<=>", RubyMethodAttributes.PublicInstance)]
+        public static int CompareTo(DateTime self, DateTime other){
+            return self.CompareTo(other);
+        }
+
+
+        [RubyMethod("mday", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("day", RubyMethodAttributes.PublicInstance)]
+        public static int Day(DateTime self){
+            return self.Day;
+        }
+
+        [RubyMethod("dup", RubyMethodAttributes.PublicInstance)]
+        public static DateTime Clone(DateTime self){
+            return new DateTime(self.Ticks, self.Kind);
+        }
+
+
+        [RubyMethod("gmtime", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("utc", RubyMethodAttributes.PublicInstance)]
+        public static DateTime ToUTC(DateTime self){
+            return self.ToUniversalTime();
+        }
+
+        [RubyMethod("gmt?", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("utc?", RubyMethodAttributes.PublicInstance)]
+        public static bool IsUTC(DateTime self){
+            return self.Equals(self.ToUniversalTime());
+        }
+
+        [RubyMethod("hour", RubyMethodAttributes.PublicInstance)]
+        public static int Hour(DateTime self){
+            return self.Hour;
+        }
+
+        [RubyMethod("dst?", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("isdst", RubyMethodAttributes.PublicInstance)]
+        public static bool IsDST(DateTime self){
+            return self.IsDaylightSavingTime();
+        }
+
+        [RubyMethod("localtime", RubyMethodAttributes.PublicInstance)]
+        public static DateTime ToLocalTime(DateTime self){
+            return self.ToLocalTime();
+        }
+
+        [RubyMethod("min", RubyMethodAttributes.PublicInstance)]
+        public static int Minute(DateTime self){
+            return self.Minute;
+        }
+
+        [RubyMethod("mon", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("month", RubyMethodAttributes.PublicInstance)]
+        public static int Month(DateTime self){
+            return self.Month;
+        }
+
+        [RubyMethod("sec", RubyMethodAttributes.PublicInstance)]
+        public static int Second(DateTime self){
+            return self.Second;
+        }
+
+        [RubyMethod("succ", RubyMethodAttributes.PublicInstance)]
+        public static DateTime SuccessiveSecond(DateTime self){
+            return self.AddSeconds(1);
+        }
+
+        [RubyMethod("to_f", RubyMethodAttributes.PublicInstance)]
+        public static double ToFloatSeconds(DateTime self){
+            double seconds = (self.ToUniversalTime().Ticks - epoch.Ticks) / 10000000.0;
+            return seconds;
+        }
+
+        [RubyMethod("tv_sec", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("to_i", RubyMethodAttributes.PublicInstance)]
+        public static BigInteger ToSeconds(DateTime self){
+            long seconds = GetSeconds(self);
+            return BigInteger.Create(seconds);
+        }
+
+        private static long GetSeconds(DateTime self){
+            return (self.ToUniversalTime().Ticks - epoch.Ticks) / 10000000;
+        }
+
+        [RubyMethod("asctime", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("ctime", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("inspect", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("to_s", RubyMethodAttributes.PublicInstance)]
+        public static MutableString ToString(DateTime self){
+            return new MutableString(self.ToString("ddd MMM dd HH:mm:ss K yyyy"));
+        }
+
+        [RubyMethod("tv_usec", RubyMethodAttributes.PublicInstance)]
+        [RubyMethod("usec", RubyMethodAttributes.PublicInstance)]
+        public static BigInteger getMicroSeconds(DateTime self){
+            long ticks = self.Ticks % 10000000;
+            return BigInteger.Create(ticks / 10);
+        }
+
+        [RubyMethod("yday", RubyMethodAttributes.PublicInstance)]
+        public static int DayOfYear(DateTime self){
+            return self.DayOfYear;
+        }
+
+        [RubyMethod("year", RubyMethodAttributes.PublicInstance)]
+        public static int Year(DateTime self){
+            return self.Year;
+        }
+
+        [RubyMethod("gmtoff")]
+        [RubyMethod("gmt_offset")]
+        [RubyMethod("utc_offset")]
+        public static object offset(DateTime self)
+        {
+            return FloatOps.CastToInteger((self - self.ToUniversalTime()).TotalSeconds);
+        }
     }
 }