mongoid-metastamp 0.0.2 → 0.0.3

data/README.md

@@ -10,22 +10,22 @@ What It Does
 (Or why would I want to use this?)
 
 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:
+But sometimes you need to search for each timestamp relative to the timezone it was created in.
+This is common when you have more than one location. 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.
+* Find all flights that depart from all airports between 1:00pm and 2:00pm local (airport) time.
+* Return all employees that clocked in later than 8:00am local time to any of our nationwide locations.
 
 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:
+date or 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.
+* Find all transactions that occurred on weekdays after 12pm in 2010.
+* Return all users that signed up the first week of every month over 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,
+Using mongoid-metastamp gives you a custom time field type that is normalized and parsed beforehand,
 and then stored in a MongoDB friendly way for easy querying.
 
 
@@ -56,17 +56,24 @@ 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
+event = MyEvent.new
+event.starts_at = Time.now
+event.ends_at = Time.now + 1.day
+event.save
+# => true
+
+event.starts_at
+# => Wed, 5 Oct 2011 20:46:22 UTC +00:00
+event.ends_at
+# => Thu, 6 Oct 2011 20:46:31 UTC +00:00
 ```
 
+
 Data Stored
 =========================
 
-When you define a `Mongoid::Metastamp::Time` field, the following meta fields also get stored inside its hash:
+However, behind the scenes the following meta fields will transparently be stored inside
+your Mongoid::Metastamp::Time field:
 
 * `time` (Date)
 * `normalized` (Date)
@@ -81,29 +88,49 @@ When you define a `Mongoid::Metastamp::Time` field, the following meta fields al
 * `offset` (Int)
 
 
-The `time` meta-field stores whatever you assign the field to.
-It will also be the value deserialized when you access the field.
+So given a field named `timestamp`:
 
 ```ruby
-field :timestamp, type: Mongoid::Metastamp::Time
+class MyEvent
+  include Mongoid::Document
+  field :timestamp, type: Mongoid::Metastamp::Time
+end
 ```
 
-For a field called `timestamp`, you can access the raw metadata fields like this:
+You can access the raw metadata fields like this:
 
 ```ruby
-event = MyEvent.new(starts_at: "2011-10-05 10:00:00 -0700")
+event = MyEvent.new(timestamp: "2011-10-05 10:00:00 -0800")
+
+event['timestamp']
+# => {"time"=>2011-10-05 17:00:00 UTC, "normalized"=>2011-10-05 10:00:00 UTC, "year"=>2011, "month"=>10, "day"=>5, "wday"=>3, "hour"=>10, "min"=>0, "sec"=>0, "zone"=>"-08:00", "offset"=>-25200}
+
 event['timestamp']['month']  # => 10
 event['timestamp']['day']    # => 5
 event['timestamp']['year']   # => 2011
-event['timestamp']['zone']   # => "-07:00"
+event['timestamp']['zone']   # => "-08:00"
+```
+
+The `time` meta-field is special and stores whatever you assign the field to.
+
+```ruby
+event['timestamp']['time']
+# => 2011-10-05 17:00:00 UTC
+```
+
+It will also be the value deserialized when you access the `timestamp` field.
+
+```ruby
+event.timestamp
+# => Wed, 05 Oct 2011 17:00:00 UTC +00: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 = MyEvent.new(timestamp: "2011-10-05 10:00:00 -0500")
+pacific_event = MyEvent.new(timestamp: "2011-10-05 10:00:00 -0800")
 
 eastern_event['timestamp']['time']        # => 2011-10-05 14:00:00 UTC
 eastern_event['timestamp']['normalized']  # => 2011-10-05 10:00:00 UTC
@@ -116,37 +143,37 @@ pacific_event['timestamp']['normalized']  # => 2011-10-05 10:00:00 UTC
 Querying
 =========================
 
-Since the `time` meta-field is the default, it can be queried as either `timestamp` or `timestamp.time`:
+Since the `time` meta-field is the default, it can be queried as just `timestamp`:
 
 ```ruby
 good_old_days = Day.where(:timestamp.lt => 20.years.ago)
 ```
 
-or...
+or as `timestamp.time`:
 
 ```ruby
 good_old_days = Day.where("timestamp.time" => { '$lt' => 20.years.ago })
 ```
 
-The other meta-fields need to be queried with the full syntax:
+For now, the other meta-fields need to be queried using the full syntax:
 
 ```ruby
 hump_days = Day.where("timestamp.wday" => 5)
-=> Only Wednesdays
+# => Only Wednesdays
 
-after_noon_delights = Delight.where("timestamp.hour" => { '$gte' => 12, '$lte' => 15 })
-=> Only between 12pm and 3pm
+afternoon_delights = Delight.where("timestamp.hour" => { '$gte' => 12, '$lt' => 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.
+See the [search specs](https://github.com/sporkd/mongoid-metastamp/blob/master/spec/time_search_spec.rb)
+for more examples.
 
 
 Todo
 ======
 
-* Add custom finders and scopes
-* Migration tasks for existing time fields
-* Additional types
+* Add custom finder methods and scopes
+* Migration task to convert existing time fields
+* Additional field types
 
 
 License

data/lib/mongoid/metastamp.rb

@@ -1,8 +1,6 @@
 # encoding: utf-8
 
 require "mongoid"
-require "mongoid/core_ext"
-
 require "mongoid/metastamp/time"
 
 module Mongoid #:nodoc:

data/lib/mongoid/metastamp/time.rb

@@ -4,7 +4,7 @@ module Mongoid #:nodoc:
   module Metastamp
     class Time
       include Mongoid::Fields::Serializable
-      include Mongoid::Fields::Serializable::Timekeeping
+      include Mongoid::Fields::Internal::Timekeeping
 
       def deserialize(object)
         return nil if object.blank?
@@ -18,7 +18,7 @@ module Mongoid #:nodoc:
         date_time = parse_datetime(object)
         { 
           time:         time,
-          normalized:   date_time.to_s.to_time,
+          normalized:   normalized_time(date_time),
           year:         date_time.year,
           month:        date_time.month,
           day:          date_time.day,
@@ -48,6 +48,12 @@ module Mongoid #:nodoc:
             value
         end
       end
+
+      def normalized_time(date_time)
+        d = ::Date._parse(date_time.to_s, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 }
+        d[6] *= 1000000
+        ::Time.utc_time(*d)
+      end
     end
   end
 end

data/lib/mongoid/metastamp/version.rb

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

data/mongoid-metastamp.gemspec

@@ -19,8 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("mongoid", "~> 2.1")
-  s.add_development_dependency("bson_ext", "~> 1.3")
+  s.add_dependency("mongoid", "~> 2.4")
   s.add_development_dependency("rake", "~> 0.9")
   s.add_development_dependency("rspec", "~> 2.6")
 end

data/spec/spec_helper.rb

@@ -2,8 +2,6 @@ require "rubygems"
 require "bundler/setup"
 
 require "mongoid"
-require "mongoid/core_ext"
-
 require "mongoid/metastamp"
 require "mongoid/metastamp/time"
 

data/spec/time_compatibility_spec.rb

@@ -5,7 +5,7 @@ require "spec_helper"
 describe "Mongoid::Metastamp::Time" do
 
   let :two_pm_pacific do
-    "2011-10-05T14:00:00-07:00"
+    "2011-10-05T14:00:00-08:00"
   end
 
   describe "compatibility with Time class" do

data/spec/time_search_spec.rb

@@ -9,11 +9,11 @@ describe "Mongoid::Metastamp::Time" do
   end
 
   let :ten_am_eastern do
-    "2011-10-05T10:00:00-04:00"
+    "2011-10-05T10:00:00-05:00"
   end
 
   let :ten_am_pacific do
-    "2011-10-05T10:00:00-07:00"
+    "2011-10-05T10:00:00-08:00"
   end
 
   context "given a 10:00 eastern and a 10:00 pacific timestamp" do
@@ -196,12 +196,12 @@ describe "Mongoid::Metastamp::Time" do
 
     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]
+      it "should return only the eastern event when searching -05:00" do
+        Event.where("timestamp.zone" => "-05: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]
+      it "should return only the pacific event when searching -08:00" do
+        Event.where("timestamp.zone" => "-08:00").to_a.should == [@pacific_event]
       end
 
     end

data/spec/time_storage_spec.rb

@@ -58,7 +58,7 @@ describe "Mongoid::Metastamp::Time" do
 
   [0, 12, 23].each do |hour|
 
-    ["+00:00", "-04:00", "-07:00", "+13:00"].each do |zone|
+    ["+00:00", "-05:00", "-08: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)

metadata

@@ -1,72 +1,59 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mongoid-metastamp
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.3
   prerelease: 
-  version: 0.0.2
 platform: ruby
-authors: 
+authors:
 - Peter Gumeson
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-11 00:00:00 -07:00
+date: 2012-02-27 00:00:00.000000000 -08:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: mongoid
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2160882720 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.1"
+      - !ruby/object:Gem::Version
+        version: '2.4'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bson_ext
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.3"
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: *2160882720
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &2160882220 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "0.9"
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *2160882220
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2160881760 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.6"
+      - !ruby/object:Gem::Version
+        version: '2.6'
   type: :development
-  version_requirements: *id004
-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: 
+  prerelease: false
+  version_requirements: *2160881760
+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: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rspec
 - Gemfile
@@ -74,7 +61,6 @@ files:
 - README.md
 - Rakefile
 - lib/mongoid-metastamp.rb
-- lib/mongoid/core_ext.rb
 - lib/mongoid/metastamp.rb
 - lib/mongoid/metastamp/time.rb
 - lib/mongoid/metastamp/version.rb
@@ -87,32 +73,29 @@ files:
 has_rdoc: true
 homepage: http://rubygems.org/gems/mongoid-metastamp
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 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.
-test_files: 
+test_files:
 - spec/models/event.rb
 - spec/spec_helper.rb
 - spec/time_compatibility_spec.rb

data/lib/mongoid/core_ext.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module Mongoid #:nodoc
-  module Fields #:nodoc:
-    module Mappings #:nodoc:
-
-      def for(klass, foreign_key = false)
-        return Serializable::Object unless klass
-        if foreign_key
-          return "#{MODULE}::ForeignKeys::#{klass.to_s.demodulize}".constantize
-        end
-        begin
-          modules = "#{MODULE}::|BSON::|ActiveSupport::"
-          if match = klass.to_s.match(Regexp.new("^(#{ modules })?(\\w+)$"))
-            "#{MODULE}::#{match[2]}".constantize
-          else
-            klass.to_s.constantize
-          end
-        rescue NameError
-          klass
-        end
-      end
-
-    end
-  end
-end