date_time_precision 0.1.0 → 0.2.0

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+**/*.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml

@@ -7,4 +7,17 @@ rvm:
   - 1.9.3
   #- 2.0.0
   - jruby-18mode
-  - jruby-19mode
+  - jruby-19mode
+gemfile:
+  - gemfiles/activesupport2.gemfile
+  - gemfiles/activesupport3.gemfile
+matrix:
+  exclude:
+    - rvm: 1.9.2
+      gemfile: gemfiles/activesupport2.gemfile
+    - rvm: 1.9.3
+      gemfile: gemfiles/activesupport2.gemfile
+    - rvm: jruby-19mode
+      gemfile: gemfiles/activesupport2.gemfile
+    - rvm: rbx-19mode
+      gemfile: gemfiles/activesupport2.gemfile

data/Gemfile

@@ -1,10 +1,3 @@
 source :rubygems
 
-# Specify your gem's dependencies in date_time_precision.gemspec
 gemspec
-
-if RUBY_VERSION < '1.9'
-  gem 'activesupport', '~> 2.3.5'
-else
-  gem 'activesupport', '~> 3'
-end

data/README.md

@@ -40,6 +40,34 @@ The gem adds the following instance methods to Date, Time, and/or DateTime:
 *    min?
 *    sec?
 
+## Formats
+
+It is useful to convert the various time classes into other formats that preserve the precision. The currently supported formats are Hash and JSON.
+
+Examples:
+
+```ruby
+require 'date_time_precision/format/hash'
+
+date = Date.new(2000, 10)
+hash = date.to_h
+ => {:year=>2000, :mon=>10}
+
+hash.to_date.precision
+ => 2 
+```
+
+```ruby
+require 'date_time_precision/format/json'
+
+date = Date.new(2000, 10)
+puts json = date.to_json
+ => {"year":2000,"mon":10}
+
+JSON.parse(json).to_date.precision
+ => 2
+```
+
 ## Compatibility
 
 Tested in MRI 1.8.7/1.9.2/1.9.3, REE, JRuby 1.8/1.9, and Rubinius 1.8/1.9.
@@ -64,8 +92,10 @@ Or install it yourself as:
 
 ## Wishlist
 
-*   Support Time::mktime, Time::utc, Time::local
-*   Support easy string formatting based on precision
+ - [x] Support Time::mktime
+ - [ ] Support Time::utc
+ - [ ] Support Time::local
+ - [ ] Support easy string formatting based on precision
 
 ## Contributing
 

data/date_time_precision.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = DateTimePrecision::VERSION
   
-  gem.add_development_dependency 'rake', '>= 0.9.2'
-  gem.add_development_dependency 'rspec', '~> 2.10.0'
-  #gem.add_development_dependency 'ruby-debug'
-  #gem.add_development_dependency 'ruby-debug19'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'activesupport'
+  gem.add_development_dependency 'json'
 end

data/gemfiles/activesupport2.gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem 'rake'
+gem 'rspec'
+gem 'json'
+
+gem 'activesupport', '~> 2', :require => false

data/gemfiles/activesupport3.gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem 'rake'
+gem 'rspec'
+gem 'json'
+
+gem 'activesupport', '~> 3', :require => false

data/lib/date_time_precision/format/hash.rb

@@ -0,0 +1,44 @@
+require 'date_time_precision/lib'
+
+class Hash
+  DATE_FORMATS = {
+    :short => [:y, :m, :d],
+    :long => [:year, :month, :day],
+    :ruby => [:year, :mon, :mday, :hour, :min, :sec, :sec_frac]
+  }
+  DATE_FORMATS[:default] = DATE_FORMATS[:ruby]
+  
+  def to_time
+    Time.mktime(*date_time_args)
+  end
+  
+  def to_datetime
+    DateTime.new(*date_time_args.take(DateTime::MAX_PRECISION))
+  end
+  
+  def to_date
+    Date.new(*date_time_args.take(Date::MAX_PRECISION))
+  end
+  
+  protected
+  def date_time_args
+    [self[:year] || self[:y] || self['year'] || self['y'],
+    self[:mon] || self[:m] || self[:month] || self['mon'] || self['m'] || self['month'],
+    self[:mday] || self[:d] || self[:day] || self['mday'] || self['d'] || self['day'],
+    self[:hour] || self[:h] || self[:hr] || self['hour'] || self['h'] || self['hr'],
+    self[:min] || self['min'],
+    self[:sec] || self[:s] || self['sec'] || self['s'],
+    self[:sec_frac] || self['sec_frac']]
+  end
+end
+
+module DateTimePrecision
+  def to_h(format = nil)
+    keys = Hash::DATE_FORMATS[format || :default]
+    
+    Hash[keys.each_with_index.map do |key,i|
+      attribute_name = Hash::DATE_FORMATS[:ruby][i]
+      [key, self.send(attribute_name)] if self.send("#{attribute_name}?")
+    end.compact]
+  end
+end

data/lib/date_time_precision/format/json.rb

@@ -0,0 +1,27 @@
+require 'date_time_precision/format/hash'
+
+if defined?(ActiveSupport)
+  require 'active_support/json/encoding'
+  
+  [Date, Time, DateTime].each do |klass|
+    klass.class_eval do
+      def as_json(*args)
+        to_h
+      end
+      
+      def to_json(opts = {})
+        to_h.to_json(opts)
+      end
+    end
+  end
+end
+
+module DateTimePrecision
+  def as_json(*args)
+    to_h
+  end
+  
+  def to_json(opts = {})
+    to_h.to_json(opts)
+  end
+end

data/lib/date_time_precision/lib.rb

@@ -11,6 +11,16 @@ module DateTimePrecision
   
     # Default values for y,m,d,h,m,s,frac
     NEW_DEFAULTS = [-4712,1,1,0,0,0,0]
+    
+    DATE_ATTRIBUTES = {
+      :year => YEAR,
+      :mon => MONTH,
+      :mday => DAY,
+      :hour => HOUR,
+      :min => MIN,
+      :sec => SEC,
+      :sec_frac => FRAC
+    }
   end
 
   # Returns the precision for this Date/Time object, or the
@@ -30,7 +40,7 @@ module DateTimePrecision
       val.precision
     when Hash
       case
-      when val[:sec_frac]
+      when val[:sec_frac], val[:subsec]
         FRAC
       when val[:sec]
         SEC
@@ -38,9 +48,9 @@ module DateTimePrecision
         MIN
       when val[:hour]
         HOUR
-      when val[:mday]
+      when val[:mday], val[:day]
         DAY
-      when val[:mon]
+      when val[:mon], val[:month]
         MONTH
       when val[:year]
         YEAR
@@ -54,33 +64,11 @@ module DateTimePrecision
     end
   end
 
-  def subsec?
-    return self.precision >= FRAC
-  end
-
-  def sec?
-    return self.precision >= SEC
-  end
-
-  def min?
-    return self.precision >= MIN
-  end
-
-  def hour?
-    return self.precision >= HOUR
-  end
-  
-  def year?
-    return self.precision >= YEAR
-  end
-
-  def month?
-    return self.precision >= MONTH
-  end
-  alias_method :mon?, :month?
-
-  def day?
-    return self.precision >= DAY
+  # Define attribute query methods
+  DATE_ATTRIBUTES.each do |attribute_name, precision|
+    define_method "#{attribute_name}?" do
+      return self.precision >= precision
+    end
   end
   
   def fragments
@@ -99,6 +87,11 @@ module DateTimePrecision
     self.class::partial_match?(self, date2)
   end
   
+  def normalize_new_args(args)
+    self.class.normalize_new_args(args)
+  end
+  protected :normalize_new_args
+  
   module ClassMethods
     def partial_match?(date1, date2)
       return true if date1.nil? or date2.nil?
@@ -112,6 +105,14 @@ module DateTimePrecision
       val = val.take(self::MAX_PRECISION) if val.is_a? Array
       DateTimePrecision::precision(val)
     end
+    
+    def normalize_new_args(args)
+      unless args.all?
+        args = args.compact
+        args = args.concat(DateTimePrecision::NEW_DEFAULTS.slice(args.length, DateTimePrecision::NEW_DEFAULTS.length - args.length))
+      end
+      args.take(self::MAX_PRECISION)
+    end
   end
 
   def self.included(base)
@@ -132,5 +133,21 @@ module DateTimePrecision
     
     # Extend with this module's class methods
     base.extend(ClassMethods)
+    
+    base.instance_eval do
+      if method_defined?(:usec)
+        alias_method :usec?, :sec_frac?
+        alias_method :sec_frac, :usec
+      end
+      
+      if method_defined?(:subsec)
+        alias_method :subsec?, :sec_frac?
+      end
+
+      alias_method :month?, :mon?
+
+      alias_method :mday, :day
+      alias_method :day?, :mday?
+    end
   end
 end

data/lib/date_time_precision/patch.rb

@@ -1,4 +1,15 @@
 require 'date_time_precision/lib'
 
-require 'date_time_precision/patch/nil'
-Dir["#{File.dirname(__FILE__)}/patch/#{RUBY_VERSION}/*.rb"].each {|f| require f }
+require 'date_time_precision/format/nil'
+
+DateTimePrecision::PATCH_VERSION = begin
+  if defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx')
+    #JRuby and Rubinius implement the Date/Time classes in pure Ruby, so they can use the 1.9.2 patch
+    RUBY_VERSION >= '1.9' ? '1.9.2' : '1.8.7'
+  else
+    RUBY_VERSION
+  end
+end
+      
+
+Dir["#{File.dirname(__FILE__)}/patch/#{DateTimePrecision::PATCH_VERSION}/*.rb"].each {|f| require f }

data/lib/date_time_precision/patch/1.8.7/time.rb

@@ -6,13 +6,29 @@ class Time
   
   MAX_PRECISION = DateTimePrecision::SEC
 
-  def self.parse(date, now=self.now)
-    d = Date._parse(date, false)
-    year = d[:year]
-    year = yield(year) if year && block_given?
-    t = make_time(year, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
-    t.precision = DateTimePrecision::precision(d)
-    t
+  class << self
+    alias_method :mktime_orig, :mktime
+    def mktime(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = mktime_orig(*[time_args, args].flatten)
+      t.precision = precision
+      t
+    end
+    
+    alias_method :make_time_orig, :make_time
+    def make_time(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = make_time_orig(*[time_args, args].flatten)
+      t.precision = precision
+      t
+    end
+    private :make_time
   end
 
   #def self.strptime(str='-4712-01-01', fmt='%F', sg=Date::ITALY)

data/lib/date_time_precision/patch/1.9.2/time.rb

@@ -4,15 +4,31 @@ require 'time'
 class Time
   include DateTimePrecision
   
-  MAX_PRECISION = DateTimePrecision::SEC
+  MAX_PRECISION = DateTimePrecision::FRAC
 
-  def self.parse(date, now=self.now)
-    d = Date._parse(date, false)
-    year = d[:year]
-    year = yield(year) if year && block_given?
-    t = make_time(year, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
-    t.precision = DateTimePrecision::precision(d)
-    t
+  class << self
+    alias_method :mktime_orig, :mktime
+    def mktime(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = mktime_orig(*[time_args, args].flatten)
+      t.precision = precision
+      t
+    end
+    
+    alias_method :make_time_orig, :make_time
+    def make_time(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = make_time_orig(*[time_args, args].flatten)
+      t.precision = precision
+      t
+    end
+    private :make_time
   end
 
   #def self.strptime(str='-4712-01-01', fmt='%F', sg=Date::ITALY)

data/lib/date_time_precision/patch/1.9.3/date.rb

@@ -10,7 +10,8 @@ class Date
     alias_method :new_orig, :new
     def new(*args)
       precision = self.precision(args)
-      d = new_orig(*args)
+      
+      d = new_orig(*normalize_new_args(args))
       d.precision= precision
       d
     end
@@ -27,13 +28,10 @@ class Date
     
     alias_method :civil_orig, :civil
     def civil(y=nil, m=nil, d=nil, sg=ITALY)
-      vals = [y,m,d]
-      precision = self.precision(vals)
-      unless vals.all?
-        vals = vals.compact
-        vals = vals.concat(NEW_DEFAULTS.slice(vals.length, NEW_DEFAULTS.length - vals.length))
-      end
-      y,m,d = vals
+      args = [y,m,d]
+      precision = self.precision(args)
+
+      y,m,d = normalize_new_args(args)
     
       d = civil_orig(y,m,d,sg)
       d.precision = precision

data/lib/date_time_precision/patch/1.9.3/date_time.rb

@@ -10,7 +10,7 @@ class DateTime < Date
     alias_method :new_orig, :new
     def new(*args)
       precision = self.precision(args)
-      d = new_orig(*args)
+      d = new_orig(*normalize_new_args(args))
       d.precision= precision
       d
     end
@@ -26,16 +26,15 @@ class DateTime < Date
     end
     
     alias_method :civil_orig, :civil
-    def civil(y=nil, m=nil, d=nil, sg=Date::ITALY)
-      vals = [y,m,d]
+    def civil(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = civil_org(*[time_args, args].flatten)
       precision = self.precision(vals)
-      unless vals.all?
-        vals = vals.compact
-        vals = vals.concat(NEW_DEFAULTS.slice(vals.length, NEW_DEFAULTS.length - vals.length))
-      end
-      y,m,d = vals
     
-      dt = civil_orig(y,m,d,sg)
+      dt = civil_orig(*[normalize_new_args(vals) , sg].flatten)
       dt.precision = precision
       dt
     end

data/lib/date_time_precision/patch/1.9.3/time.rb

@@ -7,10 +7,25 @@ class Time
   MAX_PRECISION = DateTimePrecision::FRAC
 
   class << self
+    alias_method :mktime_orig, :mktime
+    def mktime(*args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = mktime_orig(*[time_args, args].flatten)
+      t.precision = precision
+      t
+    end
+    
     alias_method :make_time_orig, :make_time
     def make_time(*args)
-      t = make_time_orig(*args)
-      t.precision = self.precision(args)
+      time_args = args.shift(Time::MAX_PRECISION)
+      precision = self.precision(time_args)
+      time_args = normalize_new_args(time_args)
+      
+      t = make_time_orig(*[time_args, args].flatten)
+      t.precision = precision
       t
     end
     private :make_time

data/lib/date_time_precision/version.rb

@@ -1,3 +1,3 @@
 module DateTimePrecision
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/date_time_precision/active_support_spec.rb

@@ -1,7 +1,17 @@
 require 'spec_helper'
+require 'json'
 require 'active_support'
+
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/time/conversions'
+begin
+  require 'active_support/core_ext/datetime/conversions'
+rescue LoadError; end
+
 require 'date_time_precision'
 
+require 'date_time_precision/format/json'
+
 describe DateTimePrecision, 'Conversions' do  
   context 'when converting from Date to Time or DateTime' do
     it 'should maintain precision' do
@@ -18,4 +28,19 @@ describe DateTimePrecision, 'Conversions' do
     t.to_datetime.precision.should == DateTime::MAX_PRECISION
     t.to_date.precision.should == DateTimePrecision::DAY
   end
+  
+  it 'will convert a date to a hash' do
+    date = Date.new(1999, 10)
+    date.as_json.should == date.to_h
+  end
+  
+  it 'will retain precision when converting to and from JSON' do
+    date = Date.new(1999, 10)
+    date.precision.should == DateTimePrecision::MONTH
+    json = ActiveSupport::JSON.encode(date)
+    
+    date_from_json = ActiveSupport::JSON.decode(json).to_date
+    date_from_json.precision.should == date.precision
+    
+  end
 end

data/spec/date_time_precision/date_time_precision_spec.rb

@@ -1,140 +1,296 @@
 require 'spec_helper'
 require 'date_time_precision'
 
-describe DateTimePrecision, 'Constructors' do
-  it 'has no precision for unspecified date' do
-    d = Date.new
-    d.precision.should == DateTimePrecision::NONE
-    d.year?.should be_false
+describe DateTimePrecision do
+  context 'Constructors' do
+    it 'has no precision for unspecified date' do
+      d = Date.new
+      d.precision.should == DateTimePrecision::NONE
+      d.year?.should be_false
     
-    dt = DateTime.new
-    dt.precision.should == DateTimePrecision::NONE
-    dt.year?.should be_false
-  end
+      dt = DateTime.new
+      dt.precision.should == DateTimePrecision::NONE
+      dt.year?.should be_false
+    end
   
-  it 'has no precision for nil values' do
-    nil.precision.should == DateTimePrecision::NONE
-  end
+    it 'has no precision for nil values' do
+      nil.precision.should == DateTimePrecision::NONE
+    end
   
-  it 'has year precision when only year is supplied' do
-    d = Date.new(1982)
-    d.precision.should == DateTimePrecision::YEAR
-    d.year?.should be_true
-    d.month?.should be_false
-    d.day?.should be_false
-  end
+    it 'has year precision when only year is supplied' do
+      d = Date.new(1982)
+      d.precision.should == DateTimePrecision::YEAR
+      d.year?.should be_true
+      d.month?.should be_false
+      d.day?.should be_false
+    end
   
-  it 'has month precision when year and month are supplied' do
-    d = Date.new(1982, 11)
-    d.precision.should == DateTimePrecision::MONTH
-    d.year?.should be_true
-    d.month?.should be_true
-    d.day?.should be_false
-  end
+    it 'has month precision when year and month are supplied' do
+      d = Date.new(1982, 11)
+      d.precision.should == DateTimePrecision::MONTH
+      d.year?.should be_true
+      d.month?.should be_true
+      d.day?.should be_false
+    end
   
-  it 'has day precision when year, month, and day are passed in' do
-    dt = DateTime.new(1987,10,19)
-    dt.precision.should == DateTimePrecision::DAY
-    dt.year?.should be_true
-    dt.month?.should be_true
-    dt.day?.should be_true
-    dt.hour?.should be_false
-  end
+    it 'should have day precision when year, month, and day are passed in' do
+      dt = DateTime.new(1987,10,19)
+      dt.precision.should == DateTimePrecision::DAY
+      dt.year?.should be_true
+      dt.month?.should be_true
+      dt.day?.should be_true
+      dt.hour?.should be_false
+    end
   
-  it 'has hour precision' do
-    dt = DateTime.new(1970, 1, 2, 3)
-    dt.precision.should == DateTimePrecision::HOUR
-    dt.year?.should be_true
-    dt.month?.should be_true
-    dt.day?.should be_true
-    dt.hour?.should be_true
-    dt.min?.should be_false
-  end
+    it 'should have hour precision' do
+      dt = DateTime.new(1970, 1, 2, 3)
+      dt.precision.should == DateTimePrecision::HOUR
+      dt.year?.should be_true
+      dt.month?.should be_true
+      dt.day?.should be_true
+      dt.hour?.should be_true
+      dt.min?.should be_false
+    end
   
-  it 'should have max precision for fully specified dates/times' do
-    # Time.new is an alias for Time.now
-    [Time.new, Time.now, DateTime.now, Date.today].each do |t|
-      t.precision.should == t.class::MAX_PRECISION
+    it 'should have max precision for fully specified dates/times' do
+      # Time.new is an alias for Time.now
+      [Time.new, Time.now, DateTime.now, Date.today].each do |t|
+        t.precision.should == t.class::MAX_PRECISION
+      end
+    end
+    
+    it 'should accept nil values in the constructor' do
+      Date.new(nil).precision.should == DateTimePrecision::NONE
+      Date.new(2000, nil).precision.should == DateTimePrecision::YEAR
+      DateTime.new(2000, 1, nil).precision.should == DateTimePrecision::MONTH
+      Time.mktime(2000, 1, 1, nil, nil).precision.should == DateTimePrecision::DAY
     end
   end
-end
 
-describe DateTimePrecision, 'Parsing' do
-  it 'should have second/frac precision when parsing a timestamp' do
-    t = Time::parse('2000-2-3 00:00:00 UTC')
-    t.precision.should == DateTimePrecision::SEC
-    t.year.should == 2000
-    t.month.should == 2
-    t.day.should == 3
-  end
+  context 'Parsing' do
+    it 'should have second/frac precision when parsing a timestamp' do
+      t = Time::parse('2000-2-3 00:00:00 UTC')
+      t.precision.should == DateTimePrecision::SEC
+      t.year.should == 2000
+      t.month.should == 2
+      t.day.should == 3
+    end
   
-  it 'should have minute precision when seconds are not in the timestamp' do
-    dt = DateTime::parse('2000-1-1 00:00 EST') # => Sat, 01 Jan 2000 00:00:00 -0500
-    dt.precision.should == DateTimePrecision::MIN
-    dt.year.should == 2000
-    dt.day.should == 1
-  end
+    it 'should have minute precision when seconds are not in the timestamp' do
+      dt = DateTime::parse('2000-1-1 00:00 EST') # => Sat, 01 Jan 2000 00:00:00 -0500
+      dt.precision.should == DateTimePrecision::MIN
+      dt.year.should == 2000
+      dt.day.should == 1
+    end
   
-  it 'should have day precision wehn parsing into a Date object' do
-    d = Date::parse('2000-1-1 00:00:00 EST') # => Sat, 01 Jan 2000
-    d.precision.should == DateTimePrecision::DAY
-  end
+    it 'should have day precision wehn parsing into a Date object' do
+      d = Date::parse('2000-1-1 00:00:00 EST') # => Sat, 01 Jan 2000
+      d.precision.should == DateTimePrecision::DAY
+    end
   
-  it 'should have month precision when day is not in the parsed string' do
-    t = Time::parse('January 2000 UTC').utc # => Sat Jan 01 00:00:00 -0800 2000
-    t.precision.should == DateTimePrecision::MONTH
-    t.year.should == 2000
-    t.month.should == 1
+    it 'should have month precision when day is not in the parsed string' do
+      t = Time::parse('January 2000 UTC').utc # => Sat Jan 01 00:00:00 -0800 2000
+      t.precision.should == DateTimePrecision::MONTH
+      t.year.should == 2000
+      t.month.should == 1
+    end
   end
-end
 
-describe DateTimePrecision, 'strptime' do
-  it 'should have day precision when day is specified in date string' do
-    d = Date.strptime('02/09/1968', '%m/%d/%Y')
-    d.precision.should == DateTimePrecision::DAY
-  end
+  context 'strptime' do
+    it 'should have day precision when day is specified in date string' do
+      d = Date.strptime('02/09/1968', '%m/%d/%Y')
+      d.precision.should == DateTimePrecision::DAY
+    end
   
-  it 'should have minute precision when extracting down to the minute' do
-    dt = DateTime.strptime('2011-02-03 15:14:52','%Y-%m-%d %H:%M')
-    dt.precision.should == DateTimePrecision::MIN
-  end
+    it 'should have minute precision when extracting down to the minute' do
+      dt = DateTime.strptime('2011-02-03 15:14:52','%Y-%m-%d %H:%M')
+      dt.precision.should == DateTimePrecision::MIN
+    end
   
-  it 'should have second precision when extracting down to the second' do
-    t = DateTime.strptime('2011-02-03 15:14:52','%Y-%m-%d %H:%M:%S')
-    t.precision.should == DateTimePrecision::SEC
+    it 'should have second precision when extracting down to the second' do
+      t = DateTime.strptime('2011-02-03 15:14:52','%Y-%m-%d %H:%M:%S')
+      t.precision.should == DateTimePrecision::SEC
+    end
   end
-end
 
-describe DateTimePrecision, 'Addition' do
-  it 'will default to max precision when adding or subtracting' do
-    d = Date.new
-    d.precision.should == DateTimePrecision::NONE
-    d += 3
-    d.precision.should == Date::MAX_PRECISION
-    d -= 2
-    d.precision.should == Date::MAX_PRECISION
+  context 'Addition' do
+    it 'should default to max precision when adding or subtracting' do
+      d = Date.new
+      d.precision.should == DateTimePrecision::NONE
+      d += 3
+      d.precision.should == Date::MAX_PRECISION
+      d -= 2
+      d.precision.should == Date::MAX_PRECISION
     
-    dt = DateTime.new
-    dt.precision.should == DateTimePrecision::NONE
-    dt += 3
-    dt.precision.should == DateTime::MAX_PRECISION
-    dt -= 2
-    dt.precision.should == DateTime::MAX_PRECISION
+      dt = DateTime.new
+      dt.precision.should == DateTimePrecision::NONE
+      dt += 3
+      dt.precision.should == DateTime::MAX_PRECISION
+      dt -= 2
+      dt.precision.should == DateTime::MAX_PRECISION
     
-    t = Time::parse('January 2000 UTC').utc
-    t.precision.should == DateTimePrecision::MONTH
-    t += 10
-    t.precision.should == Time::MAX_PRECISION
-    t -= 8
-    t.precision.should == Time::MAX_PRECISION
+      t = Time::parse('January 2000 UTC').utc
+      t.precision.should == DateTimePrecision::MONTH
+      t += 10
+      t.precision.should == Time::MAX_PRECISION
+      t -= 8
+      t.precision.should == Time::MAX_PRECISION
+    end
   end
-end
 
-describe DateTimePrecision, 'Partial Matching' do
-  it 'should match when differing only in day precision' do
-    d1 = Date.new(2001,3,2)
-    d2 = Date.new(2001,3)
-    d1.partial_match?(d2).should be_true
-    d2.partial_match?(d1).should be_true
+ context 'Partial Matching' do
+    it 'should match when differing only in day precision' do
+      d1 = Date.new(2001,3,2)
+      d2 = Date.new(2001,3)
+      d1.partial_match?(d2).should be_true
+      d2.partial_match?(d1).should be_true
+    end
+  end
+
+  context 'Formats' do
+    let(:date) { Date.new(1989, 3, 11) }
+    let(:datetime) { DateTime.new(1989, 3, 11, 8, 30, 15) }
+    let(:time) do
+      args = [1989, 3, 11, 8, 30, 15]
+      args << 1 if Time::MAX_PRECISION == DateTimePrecision::FRAC
+      Time.mktime(*args)
+    end
+    
+    context 'Hash' do
+      require 'date_time_precision/format/hash'
+    
+      let(:date_hash) do
+        {
+          :year => 1989,
+          :mon => 3,
+          :mday => 11
+        }
+      end
+    
+      let(:datetime_hash) do
+        {
+          :year => 1989,
+          :mon => 3,
+          :mday => 11,
+          :hour => 8,
+          :min => 30,
+          :sec => 15,
+        }
+      end
+    
+      let(:time_hash) do
+        @time_hash = datetime_hash
+        @time_hash.merge!(:sec_frac => 1) if Time::MAX_PRECISION == DateTimePrecision::FRAC
+        @time_hash
+      end
+    
+      context 'Converting to hash' do
+        it 'should convert Date to a hash' do
+          date.to_h.should == date_hash
+        end
+      
+        it 'should convert DateTime to a hash' do
+          datetime.to_h.should == datetime_hash
+        end
+      
+        it 'should convert Time to a hash' do
+          time.to_h.should == time_hash
+        end
+      end
+      
+      context 'Converting to hash with format' do
+        let(:short_date_hash) do
+          {
+            :y => 1989,
+            :m => 3,
+            :d => 11
+          }
+        end
+        
+        let(:long_date_hash) do
+          {
+            :year => 1989,
+            :month => 3,
+            :day => 11
+          }
+        end
+        
+        it 'should convert Date to a short hash' do
+          date.to_h(:short).should == short_date_hash
+        end
+      
+        it 'should convert DateTime to a long hash' do
+          datetime.to_h(:long).should == long_date_hash
+        end
+      
+        it 'should convert Time to a custom hash' do
+          Hash::DATE_FORMATS[:custom] = [:year, :mon, :d, :h, :min, :s]
+          
+          time.to_h(:custom).should == {
+            :year => 1989,
+            :mon => 3,
+            :d => 11,
+            :h => 8,
+            :min => 30,
+            :s => 15,
+          }
+        end
+        
+        it 'should convert to the default hash format' do
+          Hash::DATE_FORMATS[:default] = Hash::DATE_FORMATS[:short]
+          date.to_h(:short).should == short_date_hash
+          Hash::DATE_FORMATS[:default] = Hash::DATE_FORMATS[:ruby]
+        end
+      end
+  
+      context 'Converting from hash' do
+        it 'should convert a hash to a Date' do
+          date_hash.to_date.should == date
+        end
+    
+        it 'should convert a hash to a DateTime' do
+          datetime_hash.to_datetime.should == datetime
+        end
+    
+        it 'should convert a hash to a Time' do
+          time_hash.to_time.should == time
+        end
+      
+        it 'should accept flexible keys' do
+          {
+            :y => 1989,
+            :m => 3,
+            :d => 11
+          }.to_date.should == date
+        
+          {
+            :year => 1989,
+            :month => 3,
+            :day => 11
+          }.to_date.should == date
+        end
+      end
+    end
+  
+    context 'JSON' do
+      require 'date_time_precision/format/json'
+      require 'json'
+    
+      it 'should convert a date to a JSON hash' do
+        date.as_json.should == date.to_h
+        date.to_json.should == date.to_h.to_json
+      end
+    
+      it 'should convert a datetime to a JSON hash' do
+        datetime.as_json.should == datetime.to_h
+        datetime.to_json.should == datetime.to_h.to_json
+      end
+      
+      it 'should convert a time to a JSON hash' do
+        time.as_json.should == time.to_h
+        time.to_json.should == time.to_h.to_json
+      end
+    end
+    
   end
 end

metadata

@@ -1,48 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: date_time_precision
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.1.0
+  version: 0.2.0
+  prerelease: 
 platform: ruby
 authors:
 - David Butler
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2013-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.2
-    none: false
-  prerelease: false
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
     none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Patches Date, Time, and DateTime ruby classes to keep track of precision
 email:
 - dwbutler@ucla.edu
@@ -57,11 +89,14 @@ files:
 - README
 - README.md
 - Rakefile
-- date.rb
-- date_time.rb
 - date_time_precision.gemspec
 - gem_tasks/rspec.rake
+- gemfiles/activesupport2.gemfile
+- gemfiles/activesupport3.gemfile
 - lib/date_time_precision.rb
+- lib/date_time_precision/format/hash.rb
+- lib/date_time_precision/format/json.rb
+- lib/date_time_precision/format/nil.rb
 - lib/date_time_precision/lib.rb
 - lib/date_time_precision/patch.rb
 - lib/date_time_precision/patch/1.8.7/date.rb
@@ -73,36 +108,38 @@ files:
 - lib/date_time_precision/patch/1.9.3/date.rb
 - lib/date_time_precision/patch/1.9.3/date_time.rb
 - lib/date_time_precision/patch/1.9.3/time.rb
-- lib/date_time_precision/patch/nil.rb
 - lib/date_time_precision/version.rb
 - spec/date_time_precision/active_support_spec.rb
 - spec/date_time_precision/date_time_precision_spec.rb
 - spec/spec_helper.rb
-- time.rb
 homepage: http://github.com/Spokeo/date_time_precision
 licenses: []
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
+      segments:
+      - 0
+      hash: 3562610931592917135
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
+      segments:
+      - 0
+      hash: 3562610931592917135
 requirements: []
-rubyforge_project:
+rubyforge_project: 
 rubygems_version: 1.8.24
-signing_key:
+signing_key: 
 specification_version: 3
 summary: Patches Date, Time, and DateTime ruby classes to keep track of precision
 test_files:

data/date.rb

@@ -1,64 +0,0 @@
-require 'date_time_precision/lib'
-require 'date'
-
-class Date
-  include DateTimePrecision
-
-  MAX_PRECISION = DateTimePrecision::DAY
-
-  def self.parse(str='-4712-01-01T00:00:00+00:00', comp=false, sg=ITALY)
-    elem = _parse(str, comp)
-    precision = DateTimePrecision::precision(elem)
-    d = new_by_frags(elem, sg)
-    d.precision = precision
-    d
-  end
-
-  def self.strptime(str='-4712-01-01', fmt='%F', sg=ITALY)
-    elem = _strptime(str, fmt)
-    precision = DateTimePrecision::precision(elem)
-    d = new_by_frags(elem, sg)
-    d.precision = precision
-    d
-  end
-
-  def self.civil(y=nil, m=nil, d=nil, sg=ITALY)
-    vals = [y,m,d]
-    precision = DateTimePrecision::precision(vals)
-    unless vals.all?
-      vals = vals.compact
-      vals = vals.concat(NEW_DEFAULTS.slice(vals.length, NEW_DEFAULTS.length - vals.length))
-    end
-    y,m,d = vals
-  
-    unless jd = (private_methods.include?(:"_valid_civil?") ? _valid_civil?(y, m, d, sg) : valid_civil?(y, m, d, sg))
-      raise ArgumentError, 'invalid date'
-    end
-  
-    d = new!(jd_to_ajd(jd, 0, 0), 0, sg)
-    d.precision = precision
-    d
-  end
-
-  class << self; alias_method :new, :civil end
-
-=begin
-Following code is unneccessary, but keeping it as an example
-  # Return the date as a human-readable string.
-  #
-  # The format used is YYYY-MM-DD, YYYY-MM, or YYYY.
-  def to_s
-    case 
-    when self.precision.nil?, self.precision >= DateTimePrecision::DAY
-      format('%.4d-%02d-%02d', year, mon, mday)
-    when self.precision == DateTimePrecision::MONTH
-      format('%.4d-%02d', year, mon)
-    when self.precision == DateTimePrecision::YEAR
-      format('%.4d', year)
-    else
-      '?'
-    end
-  end
-=end
-
-end

data/date_time.rb

@@ -1,47 +0,0 @@
-require 'date_time_precision/lib'
-require 'date'
-
-class DateTime < Date
-  include DateTimePrecision
-
-  MAX_PRECISION = DateTimePrecision::SEC
-
-  def self.parse(str='-4712-01-01T00:00:00+00:00', comp=false, sg=ITALY)
-    elem = _parse(str, comp)
-    precision = DateTimePrecision::precision(elem)
-    dt = new_by_frags(elem, sg)
-    dt.precision = precision
-    dt
-  end
-
-  def self.civil(y=nil, m=nil, d=nil, h=nil, min=nil, s=nil, of=0, sg=ITALY)
-    vals = [y,m,d,h,min,s]
-    precision = DateTimePrecision::precision(vals)
-    unless vals.all?
-      vals = vals.compact
-      vals = vals.concat(NEW_DEFAULTS.slice(vals.length, NEW_DEFAULTS.length - vals.length))
-    end
-    y,m,d,h,min,s = vals
-  
-    unless (jd = (private_methods.include?(:"_valid_civil?") ? _valid_civil?(y, m, d, sg) : valid_civil?(y, m, d, sg))) &&
-	   (fr = (private_methods.include?(:"_valid_time?") ? _valid_time?(h, min, s) : valid_time?(h, min, s)))
-      raise ArgumentError, 'invalid date'
-    end
-    if String === of
-      of = Rational(zone_to_diff(of) || 0, 86400)
-    end
-    dt = new!(jd_to_ajd(jd, fr, of), of, sg)
-    dt.precision = precision
-    dt
-  end
-
-  class << self; alias_method :new, :civil end
-
-  def self.strptime(str='-4712-01-01', fmt='%F', sg=ITALY)
-    elem = _strptime(str, fmt)
-    precision = DateTimePrecision::precision(elem)
-    d = new_by_frags(elem, sg)
-    d.precision = precision
-    d
-  end
-end

data/time.rb

@@ -1,21 +0,0 @@
-require 'date_time_precision/lib'
-require 'time'
-
-class Time
-  include DateTimePrecision
-  
-  MAX_PRECISION = DateTimePrecision::SEC
-
-  def self.parse(date, now=self.now)
-    d = Date._parse(date, false)
-    year = d[:year]
-    year = yield(year) if year && block_given?
-    t = make_time(year, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
-    t.precision = DateTimePrecision::precision(d)
-    t
-  end
-
-  #def self.strptime(str='-4712-01-01', fmt='%F', sg=Date::ITALY)
-  #  DateTime.strptime(str, fmt, sg).to_time
-  #end
-end