mongoid-metastamp 0.0.1 → 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Peter Gumeson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,31 +1,157 @@
 Mongoid Metastamp
 =========================
 
-This gem provides Mongoid with enhanced meta-timestamps which allow querying by day, month, year, min, sec, or even by local vs. universal timezone.
+Provides Mongoid with enhanced meta-timestamps that store additional parsed time metadata,
+allowing more powerful querying on specific time fields and across normalized time zones.
+
 
 What It Does
 =========================
 (Or why would I want to use this?)
 
-Storing simple timestamps is all well and good if you only need to search inside a continuous range relative to one timezone.
-Sometimes however, you might want to search for all events that occurred between 9 AM and 5 PM, but across multiple locations and timezones.
+Storing simple timestamps is all well and good if your queries are simple or involve just one timezone.
+But sometimes you need to search across multiple locations while
+ignoring timezone offsets. For example:
+
+* Find all flights that depart from any airport between 1:00pm and 2:00pm local time.
+* Return all employees that clocked in after 8:00am at either the Denver or San Diego location.
+
+Other times you want to be able to query very specific parts of the
+date/time that typically can't be accessed without parsing it:
+
+* Find all transactions that occured on weekday afternoons in 2011.
+* Return all users that signed up in January for the last 3 years.
+
+Typically to do these things, you'd need to add a bunch of of complex time ranges to your query.
+Or you might query the entire range and loop through each result, running additional tests on the parsed time.
+
+Using mongoid-metastamp gives you a custom time field type that is normalized beforehand,
+and then stored in a MongoDB friendly way for easy querying.
+
+
+Installation
+=========================
+
+In your Gemfile
+
+```
+gem 'mongoid-metastamp'
+```
+
+```
+$ bundle install
+```
+
+Usage
+=========================
+
+For the most part, `Mongoid::Metastamp::Time` fields can be used just like regular `Time` fields:
+
+```ruby
+class MyEvent
+  include Mongoid::Document
+  field :starts_at, type: Mongoid::Metastamp::Time
+  field :ends_at,   type: Mongoid::Metastamp::Time
+end
+```
+
+```ruby
+MyEvent.create(starts_at: Time.now, ends_at: Time.now + 1.day)
+
+event = MyEvent.where(:starts_at.lt => Time.now, :ends_at.gt => Time.now).one
+event.starts_at  # => Time
+event.ends_at    # => Time
+```
+
+Data Stored
+=========================
+
+When you define a `Mongoid::Metastamp::Time` field, the following meta fields also get stored inside its hash:
 
-So you could query all possible events between some range and then run a conversion on each result to narrow it down, but that makes servers die and developers cry.
-With mongoid-metastamp you get a custom timestamp field that performs conversions when you save, and then stores the metadata in a MongoDB friendly way for easy querying.
+* `time` (Date)
+* `normalized` (Date)
+* `year` (Int)
+* `month` (Int)
+* `day` (Int)
+* `wday` (Int)
+* `hour` (Int)
+* `min` (Int)
+* `sec` (Int)
+* `zone` (String)
+* `offset` (Int)
 
-Storage
+
+The `time` meta-field stores whatever you assign the field to.
+It will also be the value deserialized when you access the field.
+
+```ruby
+field :timestamp, type: Mongoid::Metastamp::Time
+```
+
+For a field called `timestamp`, you can access the raw metadata fields like this:
+
+```ruby
+event = MyEvent.new(starts_at: "2011-10-05 10:00:00 -0700")
+event['timestamp']['month']  # => 10
+event['timestamp']['day']    # => 5
+event['timestamp']['year']   # => 2011
+event['timestamp']['zone']   # => "-07:00"
+```
+
+The `normalized` meta-field is the time normalized to a UTC value.
+This is useful when you want to query ignoring local offsets.
+
+```ruby
+eastern_event = MyEvent.new(timestamp: "2011-10-05 10:00:00 -0400")
+pacific_event = MyEvent.new(timestamp: "2011-10-05 10:00:00 -0700")
+
+eastern_event['timestamp']['time']        # => 2011-10-05 14:00:00 UTC
+eastern_event['timestamp']['normalized']  # => 2011-10-05 10:00:00 UTC
+
+pacific_event['timestamp']['time']        # => 2011-10-05 17:00:00 UTC
+pacific_event['timestamp']['normalized']  # => 2011-10-05 10:00:00 UTC
+```
+
+
+Querying
 =========================
-(What metadata should we store?)
 
-* in_zone (Date)
-* normalized (Date)
-* year (Int)
-* month (Int)
-* day (Int)
-* hour (Int)
-* min (Int)
-* sec (Int)
-* time_zone (String)
+Since the `time` meta-field is the default, it can be queried as either `timestamp` or `timestamp.time`:
+
+```ruby
+good_old_days = Day.where(:timestamp.lt => 20.years.ago)
+```
+
+or...
+
+```ruby
+good_old_days = Day.where("timestamp.time" => { '$lt' => 20.years.ago })
+```
+
+The other meta-fields need to be queried with the full syntax:
+
+```ruby
+hump_days = Day.where("timestamp.wday" => 5)
+=> Only Wednesdays
+
+after_noon_delights = Delight.where("timestamp.hour" => { '$gte' => 12, '$lte' => 15 })
+=> Only between 12pm and 3pm
+```
+See [search specs](https://github.com/sporkd/mongoid-metastamp/blob/master/spec/time_search_spec.rb)
+for more complete examples.
+
+
+Todo
+======
+
+* Add custom finders and scopes
+* Migration tasks for existing time fields
+* Additional types
+
+
+License
+========
 
+Copyright (c) 2011 Peter Gumeson.
+See [LICENSE](https://github.com/sporkd/mongoid-metastamp/blob/master/LICENSE) for full license.
 
-(More to come)

data/lib/mongoid/metastamp/time.rb

@@ -8,40 +8,45 @@ module Mongoid #:nodoc:
 
       def deserialize(object)
         return nil if object.blank?
-        super(object[:in_zone])
+        return super(object) if object.instance_of?(::Time)
+        super(object['time'])
       end
 
       def serialize(object)
+        return nil if object.blank?
         time = super(object)
-        normalized_time = normalize_time(object)
+        date_time = parse_datetime(object)
         { 
-          in_zone:      time,
-          normalized:   normalized_time,
-          year:         normalized_time.year,
-          month:        normalized_time.month,
-          day:          normalized_time.day,
-          hour:         normalized_time.hour,
-          min:          normalized_time.min,
-          sec:          normalized_time.sec
-        }
+          time:         time,
+          normalized:   date_time.to_s.to_time,
+          year:         date_time.year,
+          month:        date_time.month,
+          day:          date_time.day,
+          wday:         date_time.wday,
+          hour:         date_time.hour,
+          min:          date_time.min,
+          sec:          date_time.sec,
+          zone:         date_time.zone,
+          offset:       date_time.utc_offset
+        }.stringify_keys
       end
 
     protected
 
-      def normalize_time(object)
-        case object
+      def parse_datetime(value)
+        case value
           when ::String
-            time = ::Time.parse(object)
-          when ::DateTime
-            time = ::Time.new(object.year, object.month, object.day, object.hour, object.min, object.sec)
+            ::DateTime.parse(value)
+          when ::Time
+            offset = ActiveSupport::TimeZone.seconds_to_utc_offset(value.utc_offset)
+            ::DateTime.new(value.year, value.month, value.day, value.hour, value.min, value.sec, offset)
           when ::Date
-            time = ::Time.new(object.year, object.month, object.day)
+            ::DateTime.new(value.year, value.month, value.day)
           when ::Array
-            time = ::Time.new(*object)
+            ::DateTime.new(*value)
           else
-            time = object
+            value
         end
-        ::Time.parse(time.iso8601.sub(/-(\d\d:\d\d)$/, "-00:00"))
       end
     end
   end

data/lib/mongoid/metastamp/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Metastamp
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/mongoid-metastamp.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Peter Gumeson"]
   s.email       = ["gumeson@gmail.com"]
   s.homepage    = "http://rubygems.org/gems/mongoid-metastamp"
-  s.summary     = %q{ Store and query more useful information about your Mongoid timestamps }
-  s.description = %q{ Provides enhanced meta-timestamps for mongoid that allow querying by day, month, year, min, sec, or by local vs. universal timezone. }
+  s.summary     = %q{ Store and query more useful information about your Mongoid timestamps. }
+  s.description = %q{ Provides Mongoid with enhanced meta-timestamps that store additional parsed time metadata, allowing more powerful querying on specific time fields and across normalized time zones. }
 
   s.rubyforge_project = "mongoid-metastamp"
 

data/spec/time_compatibility_spec.rb

@@ -0,0 +1,70 @@
+#encoding: utf-8
+
+require "spec_helper"
+
+describe "Mongoid::Metastamp::Time" do
+
+  let :two_pm_pacific do
+    "2011-10-05T14:00:00-07:00"
+  end
+
+  describe "compatibility with Time class" do
+
+    class Legacy
+      include Mongoid::Document
+      field :timestamp, type: Time
+    end
+
+    let :instance do
+      Legacy.create(timestamp: two_pm_pacific).reload
+    end
+
+    context "before upgrade" do
+
+      it "should have a timestamp" do
+        instance.timestamp.should == Time.parse(two_pm_pacific)
+      end
+
+      it "should store timestamp as a Time" do
+        instance['timestamp'].class.should == Time
+      end
+
+    end
+
+    context "after Mongoid::Metastamp upgrade" do
+
+      before :each do
+        instance
+        Legacy.field(:timestamp, type: Mongoid::Metastamp::Time)
+      end
+
+      let :legacy do
+        Legacy.find(instance.id)
+      end
+
+      it "should still be able to read legacy timestamps" do
+        legacy.timestamp.should == Time.parse(two_pm_pacific)
+      end
+      
+      describe "updating timestamp with the same time" do
+
+        before :each do
+          legacy.update_attribute(:timestamp, two_pm_pacific)
+        end
+
+        it "should now store timestamp as a Hash" do
+          legacy['timestamp'].class.should == Hash
+          legacy['timestamp']['time'].should == Time.parse(two_pm_pacific)
+        end
+
+        it "should still be compatible with the legacy timestamp" do
+          legacy.timestamp.should == Time.parse(two_pm_pacific)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/time_search_spec.rb

@@ -0,0 +1,211 @@
+#encoding: utf-8
+
+require "spec_helper"
+
+describe "Mongoid::Metastamp::Time" do
+
+  let :ten_am_utc do
+    "2011-10-05T10:00:00-00:00"
+  end
+
+  let :ten_am_eastern do
+    "2011-10-05T10:00:00-04:00"
+  end
+
+  let :ten_am_pacific do
+    "2011-10-05T10:00:00-07:00"
+  end
+
+  context "given a 10:00 eastern and a 10:00 pacific timestamp" do
+
+    before :each do
+      @eastern_event = Event.create(timestamp: ten_am_eastern)
+      @pacific_event = Event.create(timestamp: ten_am_pacific)
+    end
+
+    describe "searching by timestamp" do
+
+      it "should not return any events when searching a 10:00 UTC range" do
+        Event.where(
+          :timestamp.gt => Time.parse(ten_am_utc) - 1.second,
+          :timestamp.lt => Time.parse(ten_am_utc) + 1.second
+        ).to_a.should == []
+      end
+          
+      it "should only return the ET event when searching a 10:00 ET range" do
+        Event.where(
+          :timestamp.gt =>  Time.parse(ten_am_eastern) - 1.second,
+          :timestamp.lt => Time.parse(ten_am_eastern) + 1.second
+        ).to_a.should == [@eastern_event]
+      end
+    
+      it "should only return the PT event when searching a 10:00 PT range" do
+        Event.where(
+          :timestamp.gt => Time.parse(ten_am_pacific) - 1.second,
+          :timestamp.lt => Time.parse(ten_am_pacific) + 1.second
+        ).to_a.should == [@pacific_event]
+      end
+    
+    end
+
+    describe "searching by timestamp.time" do
+
+      it "should not return any events when searching a 10:00 UTC range" do
+        Event.where(
+          "timestamp.time" => {
+            '$gt' => Time.parse(ten_am_utc) - 1.second,
+            '$lt' => Time.parse(ten_am_utc) + 1.second
+          }
+        ).to_a.should == []
+      end
+
+      it "should only return the ET event when searching a 10:00 ET range" do
+        Event.where(
+          "timestamp.time" => {
+            '$gt' => Time.parse(ten_am_eastern) - 1.second,
+            '$lt' => Time.parse(ten_am_eastern) + 1.second
+          }
+        ).to_a.should == [@eastern_event]
+      end
+
+      it "should only return the PT event when searching a 10:00 PT range" do
+        Event.where(
+          "timestamp.time" => { 
+            '$gt' => Time.parse(ten_am_pacific) - 1.second,
+            '$lt' => Time.parse(ten_am_pacific) + 1.second
+          }
+        ).to_a.should == [@pacific_event]
+      end
+
+    end
+
+    describe "searching by timestamp.normalized" do
+
+      it "should return both events when searching a 10:00 UTC range" do
+        Event.where(
+          "timestamp.normalized" => {
+            '$gt' => Time.parse(ten_am_utc) - 1.second,
+            '$lt' => Time.parse(ten_am_utc) + 1.second
+          }
+        ).to_a.should == [@eastern_event, @pacific_event]
+      end
+
+      it "should not return any events when searching a 10:00 ET range" do
+        Event.where(
+          "timestamp.normalized" => {
+            '$gt' => Time.parse(ten_am_eastern) - 1.second,
+            '$lt' => Time.parse(ten_am_eastern) + 1.second
+          }
+        ).to_a.should == []
+      end
+
+      it "should not return any events when searching a 10:00 PT range" do
+        Event.where(
+          "timestamp.normalized" => {
+            '$gt' => Time.parse(ten_am_pacific) - 1.second,
+            '$lt' => Time.parse(ten_am_pacific) + 1.second
+          }
+        ).to_a.should == []
+      end
+
+    end
+
+    describe "searching by timestamp.year" do
+
+      it "should not return any events for 2010" do
+        Event.where("timestamp.year" => 2010).count.should == 0
+      end
+
+      it "should return both events for 2011" do
+        Event.where("timestamp.year" => 2011).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.month" do
+
+      it "should not return any events when before October" do
+        Event.where("timestamp.month" => {'$lt' => 10}).count.should == 0
+      end
+
+      it "should return both events for October" do
+        Event.where("timestamp.month" => 10).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.day" do
+
+      it "should not return any events when after the 5th" do
+        Event.where("timestamp.day" => {'$gt' => 5}).count.should == 0
+      end
+
+      it "should return both events for the 5th" do
+        Event.where("timestamp.day" => 5).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.wday" do
+
+      it "should not return any events when thurs - tues" do
+        Event.where("timestamp.wday" => {'$gte' => 4, '$lte' => 2}).count.should == 0
+      end
+
+      it "should return both events for wed" do
+        Event.where("timestamp.wday" => 3).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.hour" do
+
+      it "should not return any events when before 10 AM" do
+        Event.where("timestamp.hour" => {'$lt' => 10}).count.should == 0
+      end
+
+      it "should return both events for 10 AM" do
+        Event.where("timestamp.hour" => 10).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.min" do
+
+      it "should not return any events when after 1 minute" do
+        Event.where("timestamp.min" => {'$gte' => 1}).count.should == 0
+      end
+
+      it "should return both events for 0" do
+        Event.where("timestamp.min" => 0).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.sec" do
+
+      it "should not return any events when after 1 second" do
+        Event.where("timestamp.sec" => {'$gte' => 1}).count.should == 0
+      end
+
+      it "should return both events for 0" do
+        Event.where("timestamp.sec" => 0).count.should == 2
+      end
+
+    end
+
+    describe "searching by timestamp.zone" do
+
+      it "should return only the eastern event when searching -04:00" do
+        Event.where("timestamp.zone" => "-04:00").to_a.should == [@eastern_event]
+      end
+
+      it "should return only the pacific event when searching -07:00" do
+        Event.where("timestamp.zone" => "-07:00").to_a.should == [@pacific_event]
+      end
+
+    end
+
+  end
+
+end

data/spec/time_storage_spec.rb

@@ -0,0 +1,222 @@
+#encoding: utf-8
+
+require "spec_helper"
+
+describe "Mongoid::Metastamp::Time" do
+  
+  context "when storing nil" do
+
+    context "on initialization" do
+
+      let :event do
+        Event.new(timestamp: nil)
+      end
+
+      describe "on serialization" do
+
+        it "should store timestamp as nil" do
+          event['timestamp'].should == nil
+        end
+
+      end
+
+      describe "on deserialization" do
+
+        it "timestamp should return nil" do
+          event.timestamp.should == nil
+        end
+
+      end
+
+    end
+
+    context "on creation" do
+
+      let :event do
+        Event.create(timestamp: nil).reload
+      end
+
+      describe "on serialization" do
+
+        it "should store timestamp as nil" do
+          event['timestamp'].should == nil
+        end
+
+      end
+
+      describe "on deserialization" do
+
+        it "timestamp should return nil" do
+          event.timestamp.should == nil
+        end
+
+      end
+
+    end
+
+  end
+
+  [0, 12, 23].each do |hour|
+
+    ["+00:00", "-04:00", "-07:00", "+13:00"].each do |zone|
+
+      time_utc = Time.new(2011, 12, 31, hour, 0, 0, '-00:00')
+      time = Time.new(2011, 12, 31, hour, 0, 0, zone)
+
+      context "storing time #{ time }" do
+        
+        {
+          "String"      => time.to_s,
+          "iso8601"     => time.iso8601,
+          "Time"        => time
+        }.each do |format, timestamp|
+
+          context "formatted as #{ format } (#{ timestamp })" do
+
+            context "on initialization" do
+
+              let :event do
+                Event.new(timestamp: timestamp)
+              end
+
+              describe "on serialization" do
+
+                it "should store timestamp.time" do
+                  event['timestamp']['time'].should == time
+                end
+
+                it "should store timestamp.normalized" do
+                  event['timestamp']['normalized'].should == time_utc
+                end
+
+                it "should store timestamp.year as 2011" do
+                  event['timestamp']['year'].should == 2011
+                end
+
+                it "should store timestamp.month as 12" do
+                  event['timestamp']['month'].should == 12
+                end
+
+                it "should store timestamp.day as 31" do
+                  event['timestamp']['day'].should == 31
+                end
+
+                it "should store timestamp.wday as 6 (Saturday)" do
+                  event['timestamp']['wday'].should == 6
+                end
+
+                it "should store timestamp.hour as #{ hour }" do
+                  event['timestamp']['hour'].should == hour
+                end
+
+                it "should store timestamp.min as 0" do
+                  event['timestamp']['min'].should == 0
+                end
+
+                it "should store timestamp.sec as 0" do
+                  event['timestamp']['sec'].should == 0
+                end
+
+                it "should store timestamp.zone as #{ zone }" do
+                  event['timestamp']['zone'].should == zone
+                end
+
+                it "should store timestamp.offset as #{ (zone.to_i * 60 * 60) }" do
+                  event['timestamp']['offset'].should == (zone.to_i * 60 * 60)
+                end
+
+              end
+
+              describe "on deserialization" do
+
+                it "timestamp should return #{ time }" do
+                  event.timestamp.should == time
+                end
+
+                it "timestamp should return time in UTC" do
+                  event.timestamp.zone.should == "UTC"
+                end
+
+              end
+
+            end
+
+            context "on creation" do
+
+              let :event do
+                Event.create(timestamp: timestamp).reload
+              end
+
+              describe "on serialization" do
+
+                it "should store timestamp.time" do
+                  event['timestamp']['time'].should == time
+                end
+
+                it "should store timestamp.normalized" do
+                  event['timestamp']['normalized'].should == time_utc
+                end
+
+                it "should store timestamp.year as 2011" do
+                  event['timestamp']['year'].should == 2011
+                end
+
+                it "should store timestamp.month as 12" do
+                  event['timestamp']['month'].should == 12
+                end
+
+                it "should store timestamp.day as 31" do
+                  event['timestamp']['day'].should == 31
+                end
+
+                it "should store timestamp.wday as 6 (Saturday)" do
+                  event['timestamp']['wday'].should == 6
+                end
+
+                it "should store timestamp.hour as #{ hour }" do
+                  event['timestamp']['hour'].should == hour
+                end
+
+                it "should store timestamp.min as 0" do
+                  event['timestamp']['min'].should == 0
+                end
+
+                it "should store timestamp.sec as 0" do
+                  event['timestamp']['sec'].should == 0
+                end
+
+                it "should store timestamp.zone as #{ zone }" do
+                  event['timestamp']['zone'].should == zone
+                end
+
+                it "should store timestamp.offset as #{ (zone.to_i * 60 * 60) }" do
+                  event['timestamp']['offset'].should == (zone.to_i * 60 * 60)
+                end
+
+              end
+
+              describe "on deserialization" do
+
+                it "timestamp should return #{ time }" do
+                  event.timestamp.should == time
+                end
+
+                it "timestamp should return time in UTC" do
+                  event.timestamp.zone.should == "UTC"
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -2,7 +2,7 @@
 name: mongoid-metastamp
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Peter Gumeson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-08 00:00:00 -07:00
+date: 2011-10-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,7 +57,7 @@ dependencies:
         version: "2.6"
   type: :development
   version_requirements: *id004
-description: " Provides enhanced meta-timestamps for mongoid that allow querying by day, month, year, min, sec, or by local vs. universal timezone. "
+description: " Provides Mongoid with enhanced meta-timestamps that store additional parsed time metadata, allowing more powerful querying on specific time fields and across normalized time zones. "
 email: 
 - gumeson@gmail.com
 executables: []
@@ -70,6 +70,7 @@ files:
 - .gitignore
 - .rspec
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - lib/mongoid-metastamp.rb
@@ -78,9 +79,11 @@ files:
 - lib/mongoid/metastamp/time.rb
 - lib/mongoid/metastamp/version.rb
 - mongoid-metastamp.gemspec
-- spec/metastamp_spec.rb
 - spec/models/event.rb
 - spec/spec_helper.rb
+- spec/time_compatibility_spec.rb
+- spec/time_search_spec.rb
+- spec/time_storage_spec.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/mongoid-metastamp
 licenses: []
@@ -108,8 +111,10 @@ rubyforge_project: mongoid-metastamp
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Store and query more useful information about your Mongoid timestamps
+summary: Store and query more useful information about your Mongoid timestamps.
 test_files: 
-- spec/metastamp_spec.rb
 - spec/models/event.rb
 - spec/spec_helper.rb
+- spec/time_compatibility_spec.rb
+- spec/time_search_spec.rb
+- spec/time_storage_spec.rb

data/spec/metastamp_spec.rb

@@ -1,57 +0,0 @@
-#encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Metastamp do
-
-  let :ten_am_utc do
-    "2011-10-05T10:00:00-00:00"
-  end
-
-  let :ten_am_eastern do
-    "2011-10-05T10:00:00-04:00"
-  end
-
-  let :ten_am_pacific do
-    "2011-10-05T10:00:00-07:00"
-  end
-
-  describe "with custom field of type Mongoid::Metastamp::Time" do
-
-    context "named timestamp" do
-
-      context "when set to 10:00 AM PST" do
-
-        let :pst_event do
-          Event.create(timestamp: ten_am_pacific)
-        end
-
-        it "should have a timestamp field" do
-          pst_event.should respond_to(:timestamp)
-        end
-
-        it "should deserialize the timestamp as 10 AM PST" do
-          pst_event.timestamp.should == Time.parse(ten_am_pacific)
-        end
-
-        it "should be searchable by timestamp.in_zone" do
-          Event.where(
-            "timestamp.in_zone" => { '$gt' => Time.parse(ten_am_pacific) - 1.minute },
-            "timestamp.in_zone" => { '$lt' => Time.parse(ten_am_pacific) + 1.minute }
-          ).should == [pst_event]
-        end
-
-        it "should be searchable by timestamp.normalized" do
-          Event.where(
-            "timestamp.normalized" => { '$gt' => Time.parse(ten_am_utc) - 1.minute },
-            "timestamp.normalized" => { '$lt' => Time.parse(ten_am_utc) + 1.minute }
-          ).should == [pst_event]
-        end
-
-      end
-
-    end
-
-  end
-
-end