notificon 0.0.1

data/lib/notificon.rb

@@ -0,0 +1,201 @@
+# Public: Api for the Notificon gem for tracking notifications for users
+#
+# Examples
+#
+#   Notificon.add_notification('sam', 'http://company.com/items/audha,
+#     'Item title', 'bill', :commented, Time.now)
+#
+module Notificon
+  require "notificon/notification"
+  require "notificon/user_state"
+  require "notificon/mongo_store"
+  require "notificon/cache"
+  require "notificon/notification_store"
+  require "notificon/user_state_store"
+  require "notificon/controller"
+  require 'logger'
+
+  class << self
+    # Public: accessor method used to config the gem
+    #
+    # Yields the Notificon module
+    #
+    # Examples
+    #
+    #  Notificon.setup do |config|
+    #    config.connection_profile = 'mongo://myserver/notifications'
+    #  end
+    #
+    # Returns nothing
+    def setup
+      yield self
+    end
+
+    # Public: cache to be used
+    attr_accessor :cache
+
+    # Public: Returns the query string parameter used to identify the notification.
+    #   defaults to '_notificon_id' if not set
+    def notification_id_param
+      @_notification_id_param ||= '_notificon_id'
+    end
+
+    # Public: Returns the query string parameter used to identify the notification item.
+    def notification_item_id_param
+      "#{notification_id_param}_item"
+    end
+
+    # Public: Returns the query string parameter used to identify the user.
+    def notification_username_param
+      "#{notification_id_param}_user"
+    end
+
+    # Public: Sets the String to use for the notification_id_param
+    def notification_id_param=(value)
+      raise ArgumentError.new("value must a string or nil") unless value.nil? || value.is_a?(String)
+
+      @_notification_id_param = value
+    end
+
+    # Public: Returns the connection profile for the datastore. Currently only mongo
+    #   supported. Defaults to mongodb://localhost/notificon_default if not set
+    def connection_profile
+      @_connection_profile ||= "mongodb://localhost/notificon_default"
+    end
+
+    # Public: Sets the String for the connection_profile
+    def connection_profile=(value)
+      raise ArgumentError.new("value must a string or nil") unless value.nil? || value.is_a?(String)
+
+      @_connection_profile = value
+    end
+
+    # Public: Returns the Logger currently enabled for the gem
+    #   If none specified, will create one pointing at STDOUT
+    #
+    # Returns the Logger currently configured
+    def logger
+      @_logger ||= build_logger
+    end
+
+    # Public: Setter for the Logger for the gem to use. Allows host system
+    #   loggers to be inject, eg Rails.logger
+    #
+    # value     - The Logger to use
+    #
+    # Returns the assigned Logger
+    def logger=(value)
+      @_logger = value
+    end
+
+    # Public: Mark a notification as read
+    #
+    # id        - The String identifying the notification
+    # read_at   - The Time the notitication was read
+    #
+    # Returns nothing
+    def mark_notification_read(id, read_at)
+      raise ArgumentError.new("id must be a String") unless id.is_a? String
+      raise ArgumentError.new("read_at must be a Time") unless read_at.is_a? Time
+
+      notification = notification_store.mark_as_read(id, read_at)
+      update_user_unread_counts(notification.username)
+    end
+
+    # Public: Mark a notification as read
+    #
+    # username  - The String identifying the user
+    # item_id   - The String identifying the notification item
+    # read_at   - The Time the notitication was read
+    #
+    # Returns nothing
+    def mark_all_read_for_item(username, item_id, read_at)
+      raise ArgumentError.new("username must be a String") unless username.is_a? String
+      raise ArgumentError.new("item_id must be a String") unless item_id.is_a? String
+      raise ArgumentError.new("read_at must be a Time") unless read_at.is_a? Time
+
+      notification_store.mark_all_read_for_item(username, item_id, read_at)
+      update_user_unread_counts(username)
+    end
+
+    # Public: Add a notification to the users lists
+    #
+    # username   - The String identifying the user being notified
+    # item_url   - A String url of the item notification relates to
+    # item_text  - A String that describes the item
+    # actor      - The String identifying the user that performed the action
+    # action     - A Symbol representing the action that the actor performed
+    # occured_at - The Time the action was performed
+    # item_id    - A String uniquely identifying the item the notification is for
+    #
+    # Returns the String id of the Notification generated
+    def add_notification(username, item_url, item_text, actor, action, occured_at, item_id=nil)
+      raise ArgumentError.new("username must be a String") unless username.is_a? String
+      raise ArgumentError.new("item_url must be a String") unless item_url.is_a? String
+      raise ArgumentError.new("item_text must be a String") unless item_text.is_a? String
+      raise ArgumentError.new("actor must be a String") unless actor.is_a? String
+      raise ArgumentError.new("action must be a Symbol") unless action.is_a? Symbol
+      raise ArgumentError.new("occured_at must be a Time") unless occured_at .is_a? Time
+
+      notification_store.add(Notification.new(:username => username, :item_url => item_url,
+        :item_text => item_text, :actor => actor, :action => action, :occured_at => occured_at, :item_id => item_id))
+      update_user_unread_counts(username)
+    end
+
+    # Public: Retrieve the most recent Notifications for user
+    #
+    # username   - The String identifying the user
+    # limit      - The Fixnum maximum number of items to return (default: 100)
+    #
+    # Returns Enumerable list of Notification elements
+    def get_notifications(username, limit=100)
+      raise ArgumentError.new("username must be a String") unless username.is_a? String
+      raise ArgumentError.new("limit must be a Fixnum") unless limit.is_a? Fixnum
+
+      notification_store.get_for_user(username, limit)
+    end
+
+    # Public: Retrieve the known state of the user, ie notifcation count
+    #
+    # username   - The String identifying the user
+    #
+    # Returns UserState object describing the state
+    def get_user_state(username)
+      raise ArgumentError.new("username must be a String") unless username.is_a? String
+
+      user_state_store.get(username)
+    end
+
+    # Public: Clear all unread notifications for the user
+    #
+    # username    - The String identifying the user
+    #
+    # Returns nothing
+    def clear_notifications(username)
+      raise ArgumentError.new("username must be a String") unless username.is_a? String
+
+      notification_store.mark_all_read_for_user(username, Time.now)
+      user_state_store.clear_notifications(username)
+    end
+
+    def update_user_unread_counts(username)
+      user_state_store.set_notifications(username, notification_store.unread_count_for_user(username))
+    end
+
+  private
+
+    def build_logger
+      logger = Logger.new(STDOUT)
+      logger.progname = "Notificon"
+      logger
+    end
+
+    def notification_store
+      @_notification_store ||= NotificationStore.new
+    end
+
+    def user_state_store
+      @_user_states_store ||= UserStateStore.new
+    end
+  end
+end

data/lib/notificon/cache.rb

@@ -0,0 +1,23 @@
+# Private: wrapper for the assigned cache
+#
+module Notificon
+  module Cache
+
+    def cache_enabled?
+      Notificon.cache
+    end
+
+    def cache_fetch(key)
+      if cache_enabled?
+        Notificon.cache.fetch("notificon_#{key}") { yield }
+      else
+        yield
+      end
+    end
+
+    def cache_delete(key)
+      Notificon.cache.delete("notificon_#{key}") if cache_enabled?
+    end
+  end
+
+end

data/lib/notificon/controller.rb

@@ -0,0 +1,44 @@
+# Public : Module to include in ApplicationController to support notification read tracking
+#
+# class ApplicationController
+#   include Notificon::Controller
+#   before_filter :notificon_tracker
+#
+# end
+module Notificon
+  module Controller
+    # Public : method to use as a before filter on the application controller to track read status
+    # of notifications
+    #
+    # Returns bookean indicating whether updates made
+    def notificon_tracker
+      request.get? && (_track_explicit_read | _track_implicit_read)
+    rescue => e
+      Notificon.logger.error { "Notificon::Controller#notificon_tracker error processing notification params - #{params.inspect} error - #{e.inspect}" }
+    end
+
+    # Private : uses notificon explicit parameters to track reads for items
+    def _track_explicit_read
+      if params[Notificon.notification_item_id_param] && params[Notificon.notification_username_param]
+        Notificon.mark_all_read_for_item(params[Notificon.notification_username_param], params[Notificon.notification_item_id_param], _notificon_read_at)
+        true
+      elsif id = params[Notificon.notification_id_param]
+        Notificon.mark_notification_read(id, _notificon_read_at)
+        true
+      end
+    end
+
+    # Private : uses controller methods to track implicit reads for items
+    def _track_implicit_read
+      if respond_to?(:current_username) && respond_to?(:current_item_id) && current_username && current_item_id
+        Notificon.mark_all_read_for_item(current_username, current_item_id, _notificon_read_at)
+        true
+      end
+    end
+
+    # Private : lazy assignment of read_at  time
+    def _notificon_read_at
+      @_notificon_read_at ||= ((respond_to?(:current_time) && current_time) || Time.now)
+    end
+  end
+end

data/lib/notificon/mongo_store.rb

@@ -0,0 +1,53 @@
+# Base module for interacting with the mongo store used for persistence
+
+require 'mongo'
+require 'uri'
+
+module Notificon
+  module MongoStore
+    include Mongo
+    
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    def open_connection
+      @db ||= open_store
+    end
+
+    def open_store
+      uri  = URI.parse(Notificon.connection_profile)
+      Connection.from_uri(Notificon.connection_profile).db(uri.path.gsub(/^\//, ''))
+    end
+    
+    def collection 
+      @_collection ||= open_connection[self.class.collection_name]   
+    end
+    
+    def drop_collection
+      collection.drop
+      @_collection = nil
+    end
+
+    def ensure_indexes
+      self.class.indexes.each do |index| collection.ensure_index(index) end
+    end
+
+    module ClassMethods
+      def set_collection_name(name)
+        @_collection_name = name
+      end
+      def collection_name
+        @_collection_name
+      end
+      def set_indexes(indexes)
+        @_indexes = indexes
+      end
+      def indexes
+        @_indexes || []
+      end
+    end
+  end
+end

data/lib/notificon/notification.rb

@@ -0,0 +1,33 @@
+# Class describing notification objects
+
+require 'addressable/uri'
+
+module Notificon
+  class Notification
+    attr_accessor :id, :username, :item_url, :item_text, :actor, :action, :occured_at, :read_at, :item_id
+    
+    def initialize(attrs={})
+      attrs.each_pair do |k,v| send("#{k}=", v) end
+    end
+    
+    # provided to enable simple creation from mongo hash objects
+    def _id=(value)
+      @id = value.to_s
+    end
+    
+    def read?
+      !read_at.nil?
+    end
+    
+    def url
+      uri = Addressable::URI.parse(item_url)
+      params = {Notificon.notification_id_param => id}
+      if item_id
+        params[Notificon.notification_item_id_param] = item_id 
+        params[Notificon.notification_username_param] = username 
+      end
+      uri.query_values = (uri.query_values || {}).merge(params)
+      uri.to_s
+    end
+  end
+end

data/lib/notificon/notification_store.rb

@@ -0,0 +1,46 @@
+# Private: Datamapper for Notification object
+module Notificon
+  class NotificationStore
+    include MongoStore
+    
+    set_collection_name :notificon_notifications
+    set_indexes [
+      [['username'], ['occured_at', Mongo::DESCENDING]]
+    ]
+    
+    def add(notification)
+      collection.insert('username' => notification.username, 'item_url' => notification.item_url, 
+        'item_text' => notification.item_text, 'actor' => notification.actor, 'action' => notification.action,
+        'occured_at' => notification.occured_at && notification.occured_at.utc, 'item_id' => notification.item_id).to_s
+    end
+    
+    def get(id)
+      if item_hash = collection.find_one('_id' => BSON::ObjectId.from_string(id))
+        Notification.new(item_hash)
+      end
+    end
+    
+    def get_for_user(username, limit)
+      collection.find({'username' => username}, { :limit => limit, :sort => [['occured_at', :descending]]}).collect { |item_hash|
+          Notification.new(item_hash)
+        }
+    end
+    
+    def unread_count_for_user(username)
+      collection.count(:query => {'username' => username, 'read_at' => { '$exists' => false }})
+    end
+    
+    def mark_as_read(id, read_at)
+      collection.update({'_id' => BSON::ObjectId.from_string(id)}, { '$set' => { 'read_at' => read_at.utc } })
+      get(id)
+    end
+    
+    def mark_all_read_for_user(username, read_at)
+      collection.update({'username' => username, 'read_at' => { '$exists' => false } }, { '$set' => { 'read_at' => read_at.utc}}, { :multi => true})
+    end
+
+    def mark_all_read_for_item(username, item_id, read_at)
+      collection.update({'username' => username, 'item_id' => item_id, 'read_at' => { '$exists' => false } }, { '$set' => { 'read_at' => read_at.utc}}, { :multi => true})
+    end
+  end
+end

data/lib/notificon/user_state.rb

@@ -0,0 +1,18 @@
+# Public: Encapsulates the user state
+module Notificon
+  class UserState
+    
+    # Public : Gets the username
+    attr_reader :username
+      
+    # Public : Gets the number of unread notifications
+    def notifications
+      @_notifications ||= 0
+    end
+    
+    def initialize(attrs)
+      @username = attrs['username']
+      @_notifications = attrs['notifications']
+    end
+  end
+end

data/lib/notificon/user_state_store.rb

@@ -0,0 +1,32 @@
+# Private: Datamapper for Notification object
+module Notificon
+  class UserStateStore
+    include MongoStore
+    include Cache
+
+    set_collection_name :notificon_user_state
+    set_indexes [
+      [['username']]
+    ]
+
+    def get(username)
+      if item_hash = cache_fetch("user_state_#{username}") { collection.find_one('username' => username) }
+        UserState.new(item_hash)
+      end
+    end
+
+    def set_notifications(username, notifications)
+      collection.update({'username' => username}, { '$set' => { 'notifications' => notifications }}, { :upsert => true } )
+      delete_cached(username)
+    end
+
+    def clear_notifications(username)
+      collection.update({'username' => username}, { '$set' => { 'notifications' => 0 } }, { :upsert => true })
+      delete_cached(username)
+    end
+
+    def delete_cached(username)
+      cache_delete("user_state_#{username}")
+    end
+  end
+end

data/lib/notificon/version.rb

@@ -0,0 +1,3 @@
+module Notificon
+  VERSION = "0.0.1".freeze
+end

data/spec/notificon/controller_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+class DummyController
+  include Notificon::Controller
+
+  def params
+    @_params ||= {}
+  end
+end
+
+describe Controller do
+  describe "notificon_tracker" do
+    before(:each) do
+      @controller = DummyController.new
+      @time = random_time
+      @controller.stub(:current_time) { @time }
+      @controller.stub(:request) { mock("Request", :get? => true) }
+    end
+
+    subject { @controller.notificon_tracker }
+
+    context "when id param passed" do
+      before(:each) do
+        @id = random_string
+        @controller.params[Notificon.notification_id_param] = @id
+      end
+
+      it "marks the notification as read" do
+        Notificon.should_receive(:mark_notification_read).with(@id, @time)
+        subject
+      end
+
+      context "when item_id param passed" do
+        before(:each) do
+          @item_id = random_string
+          @username = random_string
+          @controller.params[Notificon.notification_item_id_param] = @item_id
+          @controller.params[Notificon.notification_username_param] = @username
+        end
+        it "does not attempt to mark notification" do
+          Notificon.should_not_receive(:mark_notification_read)
+          subject
+        end
+        it "marks all the notifications for the item read" do
+          Notificon.should_receive(:mark_all_read_for_item).with(@username, @item_id, @time)
+          subject
+        end
+      end
+    end
+
+    context "when id param not passed" do
+      it "does not attempt to mark notification" do
+        Notificon.should_not_receive(:mark_notification_read)
+        subject
+      end
+    end
+
+    context "when controller supports current_username and current_item_id" do
+      before(:each) do
+        @current_username = random_string
+        @current_item_id = random_string
+        @controller.stub(:current_username) { @current_username }
+        @controller.stub(:current_item_id) { @current_item_id }
+      end
+      it "marks all the notifications for the current_item_id read" do
+        Notificon.should_receive(:mark_all_read_for_item).with(@current_username, @current_item_id, @time)
+        subject
+      end
+    end
+  end
+end

data/spec/notificon/notification_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'addressable/uri'
+
+describe Notification do
+  describe "#_id=" do
+    before(:each) do
+      @notification = Notification.new
+      @id = random_string
+    end
+    
+    subject { @notification._id = @id }
+    
+    it "sets the id property" do
+      subject
+      @notification.id.should eq(@id)
+    end
+  end
+  
+  describe "#read?" do
+    before(:each) do
+      @notification = Notification.new
+    end
+    
+    subject { @notification.read? }
+    
+    context "when read_at is nil" do
+      it "should be false" do
+        subject.should be_false
+      end
+    end
+    
+    context "when read_at has a value" do
+      before(:each) do
+        @notification.read_at = random_time
+      end
+      it "should be true" do
+        subject.should be_true
+      end
+    end
+  end
+  
+  describe "#url" do
+    before(:each) do
+      @id = random_string
+      @item_id = nil
+      @username = random_string
+    end
+    
+    subject { Notification.new(:id => @id, :item_url => @item_url, :item_id => @item_id, :username => @username).url }
+    
+    context "url with query string param" do    
+      before(:each) do
+        @param = random_string
+        @value = random_string
+        @item_url = "http://#{random_string}.com?#{@param}=#{@value}"
+      end
+      it "should return url with notification param appended" do
+        # having to parse result to cope with order of query string params
+        uri = Addressable::URI.parse(subject)
+        uri.query_values.should eq({ @param => @value, Notificon.notification_id_param => @id })
+      end
+    end
+    
+    context "url without query string param" do    
+      before(:each) do
+        @item_url = "http://#{random_string}.co.uk"
+      end
+      it "should return url with notification param appended" do
+        subject.should eq("#{@item_url}?#{Notificon.notification_id_param}=#{@id}")
+      end
+    end
+    
+    context "path with anchor" do
+      before(:each) do
+        @item_url = "/clubs/4f8ea8bb3d99cf0001000008/posts/4f995996cc1db30001000001#4f9fa6f673a9650001000009"
+      end
+      it "should return url" do
+        subject.should eq("/clubs/4f8ea8bb3d99cf0001000008/posts/4f995996cc1db30001000001?#{Notificon.notification_id_param}=#{@id}#4f9fa6f673a9650001000009")
+      end 
+    end
+    
+    context "when item_id present" do
+      before(:each) do
+        @item_url = "http://#{random_string}.co.uk"
+        @item_id = random_string
+      end
+      it "returns the url with both item_id and username" do
+        subject.should eq("#{@item_url}?#{Notificon.notification_id_param}=#{@id}&#{Notificon.notification_item_id_param}=#{@item_id}&#{Notificon.notification_username_param}=#{@username}")
+      end
+    end
+  end
+end

data/spec/notificon/notification_store_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe NotificationStore do
+  before(:each) do
+    @store = NotificationStore.new
+    @store.drop_collection
+  end
+  describe "#add" do
+    before(:each) do
+      @username = random_string
+      @item_text = random_string
+      @text = random_string
+      @actor = random_string
+      @action = random_string
+      @occured_at = random_time
+      @item_id = random_string
+      @notification = Notification.new(:username => @username, :item_url => @item_url, 
+        :item_text => @item_text, :actor => @actor, :action => @action, :occured_at => @occured_at, :item_id => @item_id)
+    end
+    
+    subject { @store.add(@notification) }
+    
+    it "creates a record with username set" do
+      @store.get(subject).username.should eq(@username)
+    end
+    it "creates a record with actor set" do
+      @store.get(subject).actor.should eq(@actor)
+    end
+    it "creates a record with action set" do
+      @store.get(subject).action.should eq(@action)
+    end
+    it "creates a record with occured_at set" do
+      @store.get(subject).occured_at.to_i.should eq(@occured_at.to_i)
+    end
+    it "creates a record with item_url set" do
+      @store.get(subject).item_url.should eq(@item_url)
+    end
+    it "creates a record with item_text set" do
+      @store.get(subject).item_text.should eq(@item_text)
+    end
+    it "creates a record with item_id set" do
+      @store.get(subject).item_id.should eq(@item_id)
+    end
+  end
+  
+  describe "#get_for_user" do
+    before(:each) do
+      @username = random_string
+      
+      @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.add(Notification.new(:username => random_string, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+    end
+    
+    subject { @store.get_for_user(@username, 100) }
+    
+    it "returns 2 records" do
+      subject.count.should eq(2)
+    end
+  end
+  
+  describe "#unread_count_for_user" do
+    before(:each) do
+      @username = random_string
+      
+      @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      id = @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.add(Notification.new(:username => random_string, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.mark_as_read(id, random_time)
+    end
+    
+    subject { @store.unread_count_for_user(@username) }
+    
+    it "returns 2" do
+      subject.should eq(2)
+    end
+  end
+  
+  describe "#mark_as_read" do
+    before(:each) do
+      @id = @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @read_at = random_time
+    end
+
+    subject { @store.mark_as_read(@id, @read_at) }
+    
+    it "marks the record as read_at" do
+      subject
+      @store.get(@id).read_at.to_i.should eq(@read_at.utc.to_i)
+    end
+    it "returns the Notification" do
+      subject.id.should eq(@id)
+    end
+  end
+  
+  describe "#mark_all_read_for_user" do
+    before(:each) do
+      @first_id = @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      @first_read_at = random_time
+      @store.mark_as_read(@first_id, @first_read_at)
+      
+      @second_id = @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+      
+      @third_id = @store.add(Notification.new(:username => random_string, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+
+      @fourth_id = @store.add(Notification.new(:username => @username, :item_url => random_string, :item_text => random_string, :actor => random_string, :occured_at => random_time))
+
+      @read_at = random_time
+    end
+    
+    subject { @store.mark_all_read_for_user(@username, @read_at) }
+    
+    it "leaves the first record as already read" do
+      subject
+      @store.get(@first_id).read_at.to_i.should eq(@first_read_at.to_i)
+    end
+    it "updates the second record as not read" do
+      subject
+      @store.get(@second_id).read_at.to_i.should eq(@read_at.to_i)
+    end
+    it "leaves the third record as not for the user" do
+      subject
+      @store.get(@third_id).read_at.should be_nil
+    end
+    it "updates the fourth record as not read" do
+      subject
+      @store.get(@fourth_id).read_at.to_i.should eq(@read_at.to_i)
+    end
+  end
+  
+  describe "#mark_all_read_for_item" do
+    before(:each) do
+      @item_id = random_string
+      @first_id = @store.add(Notification.new(:username => @username, :item_url => random_string, 
+        :item_text => random_string, :actor => random_string, :occured_at => random_time, :item_id => @item_id))
+      @first_read_at = random_time
+      @store.mark_as_read(@first_id, @first_read_at)
+      
+      @second_id = @store.add(Notification.new(:username => @username, :item_url => random_string, 
+        :item_text => random_string, :actor => random_string, :occured_at => random_time, :item_id => @item_id))
+      
+      @third_id = @store.add(Notification.new(:username => random_string, :item_url => random_string, 
+        :item_text => random_string, :actor => random_string, :occured_at => random_time, :item_id => @item_id))
+
+      @fourth_id = @store.add(Notification.new(:username => @username, :item_url => random_string, 
+        :item_text => random_string, :actor => random_string, :occured_at => random_time, :item_id => random_string))
+
+      @read_at = random_time
+    end
+    
+    subject { @store.mark_all_read_for_item(@username, @item_id, @read_at) }
+    
+    it "leaves the first record as already read" do
+      subject
+      @store.get(@first_id).read_at.to_i.should eq(@first_read_at.to_i)
+    end
+    it "updates the second record as not read" do
+      subject
+      @store.get(@second_id).read_at.to_i.should eq(@read_at.to_i)
+    end
+    it "leaves the third record as not for the user" do
+      subject
+      @store.get(@third_id).read_at.should be_nil
+    end
+    it "leaves the fourth record as not for the item" do
+      subject
+      @store.get(@fourth_id).read_at.should be_nil
+    end
+  end
+end

data/spec/notificon/user_state_store_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe UserStateStore do
+  before(:each) do
+    @store = UserStateStore.new
+    @store.drop_collection
+    @username = random_string
+    @store.set_notifications(@username, 2)
+  end
+
+  describe "#clear_notifications" do
+
+    subject { @store.clear_notifications(@username) }
+
+    it "should set the notifications to zero" do
+      subject
+      @store.get(@username).notifications.should eq(0)
+    end
+  end
+
+  describe "#set_notifications" do
+    before(:each) do
+      @count = random_integer
+    end
+
+    subject { @store.set_notifications(@username, @count) }
+
+    it "should set the notifications count" do
+      subject
+      @store.get(@username).notifications.should eq(@count)
+    end
+    it "should clear the cache" do
+      @store.should_receive(:cache_delete).with("user_state_#{@username}")
+      subject
+    end
+  end
+end

data/spec/notificon_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Notificon do
+  before(:each) do
+    @notification = Notification.new(:id => @id = random_string, :username => @username = random_string)
+    Notification.stub(:new) { @notification }
+
+    @unread_count = random_integer
+    @notification_store = mock(NotificationStore, :add => true, :unread_count_for_user => @unread_count, :mark_as_read => @notification)
+    Notificon.stub(:notification_store) { @notification_store }
+    @user_state_store = mock(UserStateStore, :set_notifications => true)
+    Notificon.stub(:user_state_store) { @user_state_store }
+  end
+  describe ".add_notification" do
+    before(:each) do
+      @item_url = random_string
+      @item_text = random_string
+      @actor = random_string
+      @action = random_string.to_sym
+      @occured_at = random_time
+    end
+
+    subject { Notificon.add_notification(@username, @item_url, @item_text, @actor, @action, @occured_at) }
+
+    it "creates a notification" do
+      Notification.should_receive(:new).with(:username => @username, :item_url => @item_url,
+        :item_text => @item_text, :actor => @actor, :action => @action, :occured_at => @occured_at, :item_id => nil)
+      subject
+    end
+    it "adds it to the notification store" do
+      @notification_store.should_receive(:add).with(@notification)
+      subject
+    end
+    it "updates the unread count for the user" do
+      @user_state_store.should_receive(:set_notifications).with(@username, @unread_count)
+      subject
+    end
+    context "when item id passed" do
+      before(:each) do
+        @item_id = random_string
+      end
+
+      subject { Notificon.add_notification(@username, @item_url, @item_text, @actor, @action, @occured_at, @item_id) }
+
+      it "should create the notification with the item_id" do
+        Notification.should_receive(:new).with(:username => @username, :item_url => @item_url,
+          :item_text => @item_text, :actor => @actor, :action => @action, :occured_at => @occured_at, :item_id => @item_id)
+        subject
+      end
+    end
+  end
+
+  describe "#mark_notification_read" do
+    before(:each) do
+      @read_at = random_time
+    end
+
+    subject { Notificon.mark_notification_read(@id, @read_at) }
+
+    it "marks the notification as read" do
+      @notification_store.should_receive(:mark_as_read).with(@id, @read_at)
+      subject
+    end
+    it "updates the unread count for the user" do
+      @user_state_store.should_receive(:set_notifications).with(@username, @unread_count)
+      subject
+    end
+  end
+
+  describe "#update_user_unread_counts" do
+
+    subject { Notificon.update_user_unread_counts(@username) }
+
+    it "gets the unread count for the user" do
+      @notification_store.should_receive(:unread_count_for_user).with(@username)
+      subject
+    end
+    it "sets the value on user state store" do
+      @user_state_store.should_receive(:set_notifications).with(@username, @unread_count)
+      subject
+    end
+  end
+
+  describe "#mark_all_read_for_item" do
+    before(:each) do
+      @username = random_string
+      @item_id = random_string
+      @read_at = random_time
+      @notification_store.stub(:mark_all_read_for_item)
+    end
+
+    subject { Notificon.mark_all_read_for_item(@username, @item_id, @read_at) }
+
+    it "marks all notifications for item id" do
+      @notification_store.should_receive(:mark_all_read_for_item).with(@username, @item_id, @read_at)
+      subject
+    end
+    it "updates the unread count for the user" do
+      @user_state_store.should_receive(:set_notifications).with(@username, @unread_count)
+      subject
+    end
+  end
+
+  describe ".clear_notifications" do
+    before(:each) do
+      @username = random_string
+      @notification_store.stub(:mark_all_read_for_user)
+      @user_state_store.stub(:clear_notifications)
+    end
+
+    subject { Notificon.clear_notifications(@username) }
+
+    it "marks all notifications for user as read" do
+      @notification_store.should_receive(:mark_all_read_for_user).with(@username, an_instance_of(Time))
+      subject
+    end
+    it "updates the unread count for the user" do
+      @user_state_store.should_receive(:clear_notifications).with(@username)
+      subject
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rake'
+require 'rspec'
+require "#{Rake.application.original_dir}/lib/notificon"
+
+include Notificon
+
+RSpec.configure do |config|
+  # Use color in STDOUT
+  config.color_enabled = true
+end
+
+def random_string
+  (0...24).map{ ('a'..'z').to_a[rand(26)] }.join
+end
+
+def random_integer
+  rand(9999)
+end
+
+def random_time
+  Time.now - random_integer
+end
+
+def random_object_id
+  BSON::ObjectId.from_time(random_time).to_s
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: notificon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Bird
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Gem for tracking and managing application notifications
+email: adam.bird@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/notificon/cache.rb
+- lib/notificon/controller.rb
+- lib/notificon/mongo_store.rb
+- lib/notificon/notification.rb
+- lib/notificon/notification_store.rb
+- lib/notificon/user_state.rb
+- lib/notificon/user_state_store.rb
+- lib/notificon/version.rb
+- lib/notificon.rb
+- spec/notificon/controller_spec.rb
+- spec/notificon/notification_spec.rb
+- spec/notificon/notification_store_spec.rb
+- spec/notificon/user_state_store_spec.rb
+- spec/notificon_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/adambird/notificon
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Gem for tracking and managing application notifications
+test_files:
+- spec/notificon/controller_spec.rb
+- spec/notificon/notification_spec.rb
+- spec/notificon/notification_store_spec.rb
+- spec/notificon/user_state_store_spec.rb
+- spec/notificon_spec.rb
+- spec/spec_helper.rb