duly_noted 1.0.0 → 1.0.1

data/DOCS.md

@@ -21,10 +21,6 @@ The **DulyNoted** module contains five main methods:
 
 `meta_fields`: An array of fields to retrieve from the meta hash.  If not specified, the entire hash will be grabbed.  Fields will be converted to strings, because redis converts all hash keys and values to strings.
 
-`ref_id`: If you need to reference the metric later, perhaps to add more metadata later on, you can set a reference id that you can use to update the metric.  The `ref_id` must be unique across `metric_name`s.
-
-`editable_for`: If you want to clear `ref_id`s out, you can set the metric to only be editable for a certain amount of time.  `editable_for` is defined in seconds.  After that amount of time, you will no longer be able to edit the meta data, and you may use that `ref_id` again.  By default, `ref_id`s never expire.
-
 `time_start`: The start of the time range to grab the data from.  **Important:**  `time_start` should always be the time farthest in the past.
 
 `time_end`: The end of the time range to grab the data from.  **Important:** `time_end` should always be the time closest to the present.
@@ -35,9 +31,11 @@ The **DulyNoted** module contains five main methods:
 
 ##Track
 
-_parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional), `editable_for`(optional)_
+_parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional)_
+
+_returns: `id` for editing metadata_
 
-Use track to track an event, like a page view, or a download.  Use the `for` option to give an event a context.  For instance, for page views, you might set `for` to `home_page`, so that you know which page was viewed.  You can also store metadata along with your metric with the `meta` hash.  If you need to update that `meta` hash at a later time, you can set a `ref_id`, which can be used to tell `#update` exactly which metric you want to update.  `ref_id`s have to be unique across `metric_name`s, and if you want to free up your `ref_id`s, you can set them to expire after a certain number of seconds with `editable_for`.
+Use track to track an event, like a page view, or a download.  Use the `for` option to give an event a context.  For instance, for page views, you might set `for` to `home_page`, so that you know which page was viewed.  You can also store metadata along with your metric with the `meta` hash.
 
 ###Usage
 
@@ -45,21 +43,21 @@ Use track to track an event, like a page view, or a download.  Use the `for` opt
 	
 	DulyNoted.track("video_plays", for: ["user_7261", "video_917216"], meta: {amount_watched: 0})
 	
-	DulyNoted.track("purchases", for: "user_281", generated_at: 1.day.ago, ref_id: "pid_28172", editable_for: 30)
+	DulyNoted.track("purchases", for: "user_281", generated_at: 1.day.ago)
 
 
 
 ##Update
 
-_parameters: `metric_name`, `ref_id`, `meta`(optional), `editable_for`(optional)_
+_parameters: `id`, `meta`(optional)_
 
-Use update to add, or edit the metadata stored with a metric.  You can optionally set the `editable_for` option which will override any setting set by track.  So if it was set to expire in 30 seconds, and in 20 seconds you called update with `editable_for` set to `30`, it would be editable for 30 seconds from the moment you updated it.
+Use update to add, or edit the metadata stored with a metric.
 
 ###Usage
 
-	DulyNoted.track("page_views", ref_id: "a_unique_id", meta: {time_on_page: 0, browser: "chrome"})
+	DulyNoted.track("page_views", meta: {time_on_page: 0, browser: "chrome"}) # => 5673
 	
-    DulyNoted.update("page_views", "a_unique_id", meta: { time_on_page: 30 }, editable_for: 30)
+    DulyNoted.update(5673, meta: { time_on_page: 30 })
 
 
 

data/README.md

@@ -1,5 +1,3 @@
-_Currently being updated for v1.0.0..._
-
 #Duly Noted
 [![Build Status](https://secure.travis-ci.org/willcosgrove/duly_noted.png?branch=master)](http://travis-ci.org/willcosgrove/duly_noted)
 
@@ -10,6 +8,10 @@ Duly noted is a redis backed stats and metrics tracker.  It works as follows:
 This would log one page view for the home page.  Then to see how many page views the home page has gotten, you would simply call:
 
     DulyNoted.count("page_views", for: "homepage")
+    
+To count how many page views there have been across all pages, you can call:
+
+	DulyNoted.count("page_views")
 
 You can also store meta data with your metrics by passing your data in a hash to the `meta` key like so:
 
@@ -29,6 +31,8 @@ You can also just specify a `time_range` like so:
 
 This will return the page view count for the home page for the past day.
 
+There are a few other things it can do, check out the [docs]("http://willcosgrove.github.com/duly_noted") for more info.
+
 ##Install
 
 You probably already guessed it, but to install just
@@ -43,24 +47,39 @@ to your `gemfile` and run `bundle install`
 
 ##What's New
 
+### 1.0.1
+* Obliterated `ref_id`s, and everything they stood for.  Not really everything they stood for.  Now each metric gets its own unique id.
+* `#track` now returns the id of the metric you just tracked
+* id's are unique across all of duly_noted, so when you update them with `#update` you don't need to specify which metric_name
+* The first time you run a duly_noted command after updating the gem, it will attempt to update your redis schema.  I did this on my own duly_noted setup with about 110k worth of unique metrics tracked, a DB size of 19MB, and a key count of 6 to a DB size of 35MB and a key count of 110600 in 75.26 seconds.  In the next version, I'm either going to move the id keys into a hash, so it doesn't pollute the global keyspace any more than it has to, or, I'm going to set a default expire time on each id reference key.  I'm leaning towards the expiration idea, because I don't think people have a use for being able to update any metric entry at any time.
+
+### 1.0.0
+* `for` is no longer required on `count` and `query`.  If you call one of them without `for` it will count all of whatever metric you specified
+* Added the `chart` method, which allows you to pull out your data in a handy way that's perfect for giving it to a charting library
+* Now pipelines all of the keys that are set in the `track` method
+* Added errors so that you know when something's gone wrong!
+* Added the Updater which will do redis schema upgrades automatically when duly_noted does another major upgrade
+* A special `count_x_by_y` dynamic method.  Say you've tracked page views, and in the meta hash, you've stored their browser name.  Now you want a breakdown of page views by browser, well… `DulyNoted.count_page_views_by_browser` would do just that.  Yay metaprogramming!
+* Added the ability to expire `ref_id`s.  So if you know that you'll only need to edit your metadata for, say, the next 10 minutes, you can set the `editable_for` options to `10.minutes` in the `track`, or in the `update` method.  By default, `ref_id`s never expire.
+* Some other little behind the scenes methods to help for the big surprise in 1.5.0
+
 ### 0.1.0
 
 * Added the `time_range` option to `count`, and `query`
 
 * Added the `meta_fields` option to `query`, which takes an array of fields to pull out from the meta hash
 
-* Added the `ref_id` option to `query`, which takes a reference id and will return an array with one meta hash.  I was going back and forth on whether or not it should wrap the hash in an array.  It doesn't need to be, but I thought, just to make it consistant with it's usual output, I should make it return an array.
+* Added the `ref_id` option to `query`, which takes a reference id and will return an array with one meta hash.  I was going back and forth on whether or not it should wrap the hash in an array.  It doesn't need to be, but I thought, just to make it consistent with it's usual output, I should make it return an array.
 
 * Enough bug fixes to make it production ready! Yay!
 
 
-##To Do
-
-* Count by meta fields: How many page views from each browser?
+##What's Gonna Be New
 
-* A `chart` method which would take a `time_start`, `time_end`, and a `granularity` which would allow you to easily get the per hour for each hour for the past day, for example.
+###1.5.0
+* A sinatra app to view and peruse your metrics (think, resque)
+* Resolution decay: currently, duly_noted stores all metrics at the highest resolution, timestamped down to a fraction of a second.  With resolution decay, you can specify fall offs so that after, say, a month, they'll be grouped by day.  So after a month has passed, you couldn't go back to a day and see it by hour, only total for that day.  This will tremendously cut back on space, and is, of course, totally customizable. 
 
-* Maybe some Rails view helpers to generate some code for a Javascript charting library, or Google Charts API.
 
 ##Contributing
 If you want to help, you should do it.  Fork it, fix it, and send me a pull request.  I will be delighted.

data/lib/duly_noted.rb

@@ -72,10 +72,6 @@ module DulyNoted
 # 
 # `meta_fields`: An array of fields to retrieve from the meta hash.  If not specified, the entire hash will be grabbed.  Fields will be converted to strings, because redis converts all hash keys and values to strings.
 # 
-# `ref_id`: If you need to reference the metric later, perhaps to add more metadata later on, you can set a reference id that you can use to update the metric.  The `ref_id` must be unique across `metric_name`s.
-# 
-# `editable_for`: If you want to clear `ref_id`s out, you can set the metric to only be editable for a certain amount of time.  `editable_for` is defined in seconds.  After that amount of time, you will no longer be able to edit the meta data, and you may use that `ref_id` again.  By default, `ref_id`s never expire.
-# 
 # `time_start`: The start of the time range to grab the data from.  **Important:**  `time_start` should always be the time farthest in the past.
 # 
 # `time_end`: The end of the time range to grab the data from.  **Important:** `time_end` should always be the time closest to the present.
@@ -84,16 +80,14 @@ module DulyNoted
 
   #   ##Track
 
-  # _parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional), `ref_id`(optional), `editable_for`(optional)_
-
+  # _parameters: `metric_name`, `for`(optional), `generated_at`(optional), `meta`(optional)_
+  #
+  # _returns: `id` for editing metadata_
+  #  
   # Use track to track an event, like a page view, or a download.  Use the `for` option
   # to give an event a context.  For instance, for page views, you might set `for` to
   # `home_page`, so that you know which page was viewed.  You can also store metadata
-  # along with your metric with the `meta` hash.  If you need to update that `meta` hash
-  # at a later time, you can set a `ref_id`, which can be used to tell `#update`
-  # exactly which metric you want to update.  `ref_id`s have to be unique across
-  # `metric_name`s, and if you want to free up your `ref_id`s, you can set them to expire
-  # after a certain number of seconds with `editable_for`.
+  # along with your metric with the `meta` hash.
   # 
   # ###Usage
 
@@ -107,49 +101,45 @@ module DulyNoted
   # 
   #     DulyNoted.track("purchases",
   #       for: "user_281",
-  #       generated_at: 1.day.ago,
-  #       ref_id: "pid_28172",
-  #       editable_for: 30)
+  #       generated_at: 1.day.ago)
     
   def track(metric_name, options={})
     options = {:generated_at => Time.now}.merge(options)
     key = build_key(metric_name)
+    key_without_for = key.dup
+    id = DulyNoted.redis.incr "dnid"
     key << assemble_for(options)
     DulyNoted.redis.pipelined do
-      DulyNoted.redis.sadd build_key("metrics"), build_key(metric_name)
-      DulyNoted.redis.zadd key, options[:generated_at].to_f, "#{key}:#{options[:generated_at].to_f}:meta"
-      DulyNoted.redis.set "#{build_key(metric_name)}:ref:#{options[:ref_id]}", "#{key}:#{options[:generated_at].to_f}:meta" if options[:ref_id] # set alias key
-      DulyNoted.redis.expire "#{build_key(metric_name)}:ref:#{options[:ref_id]}", options[:editable_for] if options[:editable_for]
+      DulyNoted.redis.sadd build_key("metrics", false), key_without_for
+      DulyNoted.redis.zadd key, options[:generated_at].to_f, "#{key}:#{id}:meta"
+      DulyNoted.redis.set "dnid:#{id}", "#{key}:#{id}:meta" # set alias key
       if options[:meta] # set meta data
-        DulyNoted.redis.mapped_hmset "#{key}:#{options[:generated_at].to_f}:meta", options[:meta]
+        DulyNoted.redis.mapped_hmset "#{key}:#{id}:meta", options[:meta]
         options[:meta].keys.each do |field|
           DulyNoted.redis.sadd "#{key}:fields", field
         end
       end
     end
+    id
   end
   
   #   ##Update
   # 
-  # _parameters: `metric_name`, `ref_id`, `meta`(optional), `editable_for`(optional)_
+  # _parameters: `id`, `meta`(optional)_
   # 
-  # Use update to add, or edit the metadata stored with a metric.  You can optionally set the `editable_for` option which will override any setting set by track.  So if it was set to expire in 30 seconds, and in 20 seconds you called update with `editable_for` set to `30`, it would be editable for 30 seconds from the moment you updated it.
+  # Use update to add, or edit the metadata stored with a metric.
   # 
   # ###Usage
   # 
   #     DulyNoted.track("page_views",
-  #       ref_id: "a_unique_id",
-  #       meta: {time_on_page: 0, browser: "chrome"})
-  #     DulyNoted.update("page_views",
-  #       "a_unique_id",
-  #       meta: { time_on_page: 30 },
-  #       editable_for: 30)
+  #       meta: {time_on_page: 0, browser: "chrome"}) # => 5673
+  #     DulyNoted.update(5673,
+  #       meta: { time_on_page: 30 })
   
-  def update(metric_name, ref_id, options={})
-    key = build_key(metric_name)
-    key << ":ref:#{ref_id}"
+  def update(id, options={})
+    key = "dnid:#{id}"
     real_key = DulyNoted.redis.get key
-    raise InvalidRefId if real_key == nil
+    raise InvalidId if real_key == nil
     DulyNoted.redis.mapped_hmset real_key, options[:meta] if options[:meta] 
   end
   
@@ -171,8 +161,8 @@ module DulyNoted
     key = build_key(metric_name)
     parse_time_range(options)
     key << assemble_for(options)
-    if options[:ref_id]
-      key << ":ref:#{options[:ref_id]}"
+    if options[:id]
+      key = "dnid:#{options[:id]}"
       real_key = DulyNoted.redis.get key
       if options[:meta_fields]
         options[:meta_fields].collect! { |x| x.to_s }
@@ -382,6 +372,6 @@ module DulyNoted
   class NotValidMetric < StandardError; end
   class InvalidOptions < StandardError; end
   class InvalidStep < StandardError; end
-  class InvalidRefId < StandardError; end
+  class InvalidId < StandardError; end
   class UpdateError < StandardError; end
 end

data/lib/duly_noted/helpers.rb

@@ -23,12 +23,13 @@ module DulyNoted
       end
     end
 
-    def find_keys(key)
+    def find_keys(key, redis=nil)
+      redis ||= DulyNoted.redis
       keys = []
-      keys += DulyNoted.redis.keys("#{key}*")
-      keys -= DulyNoted.redis.keys("#{key}:*:meta")
-      keys -= DulyNoted.redis.keys("#{key}:ref:*")
-      keys -= DulyNoted.redis.keys("#{key}*fields")
+      keys += redis.keys("#{key}*")
+      keys -= redis.keys("#{key}:*:meta")
+      keys -= redis.keys("#{key}:ref:*")
+      keys -= redis.keys("#{key}*fields")
     end
 
     def parse_time_range(options)

data/lib/duly_noted/updater.rb

@@ -1,11 +1,37 @@
 require "duly_noted/version"
+require "duly_noted/helpers"
 
 module DulyNoted
   module Updater
     def update_schema(schema_version, redis)
-      # magic updating!
+      time = Time.now
+      if schema_version = [1,0,0]
+        #update to 1.0.1
+        puts "Updating schema to comply with duly_noted 1.0.1"
+        metrics = redis.smembers "dn:metrics"
+        metrics.each do |metric|
+          keys = find_keys(metric, redis)
+          keys.each do |key|
+            events = redis.zrange key, 0, -1
+            events.each do |event|
+              id = redis.incr "dnid"
+              redis.zadd(key, redis.zscore(key, event), event.gsub(/:\d{10}.\d+:/, ":#{id}:"))
+              redis.set("dnid:#{id}", "#{key}:#{id}:meta")
+              if(redis.exists(event))
+                redis.mapped_hmset "#{key}:#{id}:meta", redis.hgetall(event)
+                redis.del(event)
+              end
+              redis.zrem(key, event)
+            end
+          end
+        end
+        redis.keys("*:ref:*").each do |ref_keys|
+          redis.del(ref_keys)
+        end
+        schema_version = [1,0,1]
+      end
       redis.set "dn:version", VERSION
-      puts "All up to date"
+      puts "All up to date.  Completed updates in #{Time.now-time} seconds."
       return true
     end
 
@@ -14,9 +40,8 @@ module DulyNoted
       if !schema_version.nil?
         schema_version = schema_version.split(".")
         current_version = VERSION.split(".")
-        if schema_version[0] != current_version[0]
-          puts "Your duly_noted schema needs to be updated"
-          if update_schema(schema_version.join("."), redis)
+        if schema_version != current_version
+          if update_schema(schema_version, redis)
             check_schema(redis)
           else
             raise UpdateError

data/lib/duly_noted/version.rb

@@ -1,3 +1,3 @@
 module DulyNoted
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/duly_noted_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe DulyNoted do
   before :each do
-    DulyNoted.redis.flushall
+    DulyNoted.redis.flushdb
     Timecop.return
   end
 
@@ -32,27 +32,23 @@ describe DulyNoted do
       DulyNoted.track "page_views", :generated_at => Time.now-10
       DulyNoted.count "page_views", :time_range => Time.now-11..Time.now-9
     end
-    it "will allow you to set expirations on `ref_id`s" do
-      DulyNoted.track "page_views", :meta => {:open => true}, :ref_id => "unique", :editable_for => 0
-      expect { DulyNoted.update("page_views", "unique") }.to raise_error(DulyNoted::InvalidRefId)
-    end
   end
 
   describe "#update" do
     it "overwrites duplicate keys" do
-      DulyNoted.track "page_views", :meta => {:seconds_open => 0}, :ref_id => "unique"
-      DulyNoted.update "page_views", "unique", :meta => {:seconds_open => 5}
+      id = DulyNoted.track "page_views", :meta => {:seconds_open => 0}
+      DulyNoted.update id, :meta => {:seconds_open => 5}
       DulyNoted.query("page_views").should include({"seconds_open" => "5"})
       DulyNoted.query("page_views").should_not include({"seconds_open" => "0"})
     end
     it "doesn't replace old hash" do
-      DulyNoted.track "page_views", :meta => {:seconds_open => 0}, :ref_id => "unique"
-      DulyNoted.update "page_views", "unique", :meta => {:ip_address => "19.27.182.32"}
+      id = DulyNoted.track "page_views", :meta => {:seconds_open => 0}
+      DulyNoted.update id, :meta => {:ip_address => "19.27.182.32"}
       DulyNoted.query("page_views").should include({"seconds_open" => "0", "ip_address" => "19.27.182.32"})
     end
     it "does not require that `for:` be set to update" do
-      DulyNoted.track "page_views", :for => "home", :meta => {:seconds_open => 0}, :ref_id => "unique"
-      DulyNoted.update "page_views", "unique", :meta => {:seconds_open => 5}
+      id = DulyNoted.track "page_views", :for => "home", :meta => {:seconds_open => 0}
+      DulyNoted.update id, :meta => {:seconds_open => 5}
       DulyNoted.query("page_views").should include({"seconds_open" => "5"})
     end
   end
@@ -62,11 +58,11 @@ describe DulyNoted do
       DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}
       DulyNoted.query("page_views").should include({"seconds_open" => "0", "browser" => "chrome"})
     end
-    it "can query a certain ref_id" do
-      DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}, :ref_id => "unique"
+    it "can query a certain id" do
+      id = DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}
       DulyNoted.track "page_views", :meta => {:seconds_open => 10, :browser => "firefox"}
-      DulyNoted.query("page_views", :ref_id => "unique").should include({"seconds_open" => "0", "browser" => "chrome"})
-      DulyNoted.query("page_views", :ref_id => "unique").should_not include({"seconds_open" => "10", "browser" => "firefox"})
+      DulyNoted.query("page_views", :id => id).should include({"seconds_open" => "0", "browser" => "chrome"})
+      DulyNoted.query("page_views", :id => id).should_not include({"seconds_open" => "10", "browser" => "firefox"})
     end
     it "can grab only specific fields from the hash" do
       DulyNoted.track "page_views", :meta => {:seconds_open => 0, :browser => "chrome"}
@@ -123,19 +119,19 @@ describe DulyNoted do
       DulyNoted.chart("page_views", :time_range => Time.now-(3)..Time.now-(1), :step => (1)).should eq({(Time.now-3).to_i => 1, (Time.now-2).to_i => 2, (Time.now-1).to_i => 3})
     end
     it "can count events between a time range, without a step set" do
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
-      DulyNoted.chart("page_views", :time_range => Chronic.parse("yesterday at 12am")...Chronic.parse("yesterday at 2am"), :data_points => 2).should eq({Chronic.parse("yesterday at 12am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30pm")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20pm")
+      DulyNoted.chart("page_views", :time_range => Chronic.parse("yesterday at 12pm")...Chronic.parse("yesterday at 2pm"), :data_points => 2).should eq({Chronic.parse("yesterday at 12pm").to_i => 1, Chronic.parse("yesterday at 1pm").to_i => 1})
     end
     it "will take time_start, step, and data_points options to build a chart" do
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
-      DulyNoted.chart("page_views", :time_start => Chronic.parse("yesterday at 12am"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 12am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30pm")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20pm")
+      DulyNoted.chart("page_views", :time_start => Chronic.parse("yesterday at 12pm"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 12pm").to_i => 1, Chronic.parse("yesterday at 1pm").to_i => 1})
     end
     it "will take time_end, step, and data_points options to build a chart" do
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
-      DulyNoted.chart("page_views", :time_end => Chronic.parse("yesterday at 2am"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 2am").to_i => 1, Chronic.parse("yesterday at 1am").to_i => 1})
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30pm")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20pm")
+      DulyNoted.chart("page_views", :time_end => Chronic.parse("yesterday at 2pm"), :step => (3600), :data_points => 2).should eq({Chronic.parse("yesterday at 2pm").to_i => 1, Chronic.parse("yesterday at 1pm").to_i => 1})
     end
     it "should raise InvalidStep if you give it a step of zero" do
       DulyNoted.track "page_views"
@@ -146,9 +142,9 @@ describe DulyNoted do
       expect { DulyNoted.chart("page_views", :time_end => Time.now, :step => 60*60) }.to raise_error(DulyNoted::InvalidOptions)
     end
     it "should chart everything if no time range is specified" do
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30am")
-      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20am")
-      DulyNoted.chart("page_views", :data_points => 2).should eq({Chronic.parse("yesterday at 12:30am").to_i => 1, Chronic.parse("yesterday at 12:55am").to_i => 1})
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 12:30pm")
+      DulyNoted.track "page_views", :generated_at => Chronic.parse("yesterday at 1:20pm")
+      DulyNoted.chart("page_views", :data_points => 2).should eq({Chronic.parse("yesterday at 12:30pm").to_i => 1, Chronic.parse("yesterday at 12:55pm").to_i => 1})
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duly_noted
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000 Z
+date: 2012-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70176012443720 !ruby/object:Gem::Requirement
+  requirement: &70148931411020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70176012443720
+  version_requirements: *70148931411020
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70176012459660 !ruby/object:Gem::Requirement
+  requirement: &70148931410600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012459660
+  version_requirements: *70148931410600
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70176012459240 !ruby/object:Gem::Requirement
+  requirement: &70148931410180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012459240
+  version_requirements: *70148931410180
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
-  requirement: &70176012458820 !ruby/object:Gem::Requirement
+  requirement: &70148931409760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012458820
+  version_requirements: *70148931409760
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70176012458400 !ruby/object:Gem::Requirement
+  requirement: &70148931409340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012458400
+  version_requirements: *70148931409340
 - !ruby/object:Gem::Dependency
   name: guard-bundler
-  requirement: &70176012457980 !ruby/object:Gem::Requirement
+  requirement: &70148931408920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012457980
+  version_requirements: *70148931408920
 - !ruby/object:Gem::Dependency
   name: chronic
-  requirement: &70176012457560 !ruby/object:Gem::Requirement
+  requirement: &70148931408500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012457560
+  version_requirements: *70148931408500
 - !ruby/object:Gem::Dependency
   name: timecop
-  requirement: &70176012457140 !ruby/object:Gem::Requirement
+  requirement: &70148931424440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012457140
+  version_requirements: *70148931424440
 - !ruby/object:Gem::Dependency
   name: ruby_gntp
-  requirement: &70176012456720 !ruby/object:Gem::Requirement
+  requirement: &70148931424020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,7 +109,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70176012456720
+  version_requirements: *70148931424020
 description: a simple redis based stat-tracker
 email:
 - will@willcosgrove.com
@@ -146,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2593334725054151131
+      hash: -502772928455294375
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -155,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2593334725054151131
+      hash: -502772928455294375
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.16