unread-mongoid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0de8df9d08d0700507b4e45252f7dfa78328f19f
+  data.tar.gz: 028872b091dedaf7bad1c803f38cad621d2ef681
+SHA512:
+  metadata.gz: 38fc2a6c00adb96aa4972014bd3b1fbb94189c64f12a348ccf042674f26f752f8503a474462149796f38bb3926374d4ce1560c3d1ee82b3f868db728eca6f918
+  data.tar.gz: 3a0b7e197a0d142869ae2ccce5412a23de724f26bd9eb0d4ab83dec630994978087ceb2b385c6e90758b42704f35154aef73a8ad33772a7e47ecef5db60a5ad4

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+*.swp
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in unread.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010,2013 Georg Ledermann
+
+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

@@ -0,0 +1,76 @@
+Unread-Mongoid
+======
+
+Ruby gem to manage read/unread status of Mongoid objects.
+
+## Credit
+First and foremost this is a fork of [Unread](https://github.com/ledermann/unread) by [Georg Ledermann](http://www.georg-ledermann.de). If you don't have to use Mongo for this I highly reccoment you use his gem, this is a task much better suited to a relational db, I had to remove some features to make it work for Mongoid.
+
+## Features
+
+* Manages unread records for anything you want users to read (like messages, documents, comments etc.)
+* Supports _mark as read_ to mark a **single** record as read
+* Supports _mark all as read_ to mark **all** records as read in a single step
+* Gives you a scope to get the unread or read records for a given user
+* Needs only one additional collection
+
+
+## Requirements
+
+* Ruby 1.8.7 or 1.9.3 or 2.0.0
+* Rails 3 (including 3.0, 3.1, 3.2) and Rails 4.
+* Needs a timestamp field in your models (like created_at or updated_at) with a database index on it
+
+
+## Installation
+
+Step 1: Add this to your Gemfile:
+
+```ruby
+gem 'unread-mongoid'
+```
+
+and run
+
+```shell
+bundle
+```
+
+
+## Usage
+
+```ruby
+class User
+  include Mongoid::Document
+  include UnreadMongoid
+
+  acts_as_reader
+end
+
+class Message
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  include UnreadMongoid
+  acts_as_readable :on => :created_at
+end
+
+message1 = Message.create!
+message2 = Message.create!
+
+## Get unread messages for a given user
+Message.unread_by(current_user).entries
+# => [ message1, message2 ]
+
+message1.mark_as_read! :for => current_user
+Message.unread_by(current_user).entries
+# => [ message2 ]
+
+Message.mark_as_read! :all, :for => current_user
+Message.unread_by(current_user).entries
+# => [ ]
+
+# Optional: Cleaning up unneeded markers.
+# Do this in a cron job once a day.
+Message.cleanup_read_marks!
+```

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the unread plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/changelog.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.0.1 - 2013-07-31
+
+* Converted to from Unread

data/lib/generators/unread/migration/migration_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module UnreadMongoid
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for read_markers"
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/unread_migration'
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+  end
+end

data/lib/generators/unread/migration/templates/migration.rb

@@ -0,0 +1,16 @@
+class UnreadMigration < ActiveRecord::Migration
+  def self.up
+    create_table :read_marks, :force => true do |t|
+      t.integer  :readable_id
+      t.integer  :user_id,       :null => false
+      t.string   :readable_type, :null => false, :limit => 20
+      t.datetime :timestamp
+    end
+
+    add_index :read_marks, [:user_id, :readable_type, :readable_id]
+  end
+
+  def self.down
+    drop_table :read_marks
+  end
+end

data/lib/unread_mongoid/base.rb

@@ -0,0 +1,39 @@
+module UnreadMongoid
+  def self.included(base)
+    base.extend Base
+  end
+
+  module Base
+    def acts_as_reader
+      ReadMark.belongs_to :user, :class_name => self.to_s
+
+      has_many :read_marks, :dependent => :delete_all, :foreign_key => 'user_id', :inverse_of => :user
+
+      after_create do |user|
+        # We assume that a new user should not be tackled by tons of old messages
+        # created BEFORE he signed up.
+        # Instead, the new user starts with zero unread messages
+        (ReadMark.readable_classes || []).each do |klass|
+          klass.mark_as_read! :all, :for => user
+        end
+      end
+
+      include Reader::InstanceMethods
+    end
+
+    def acts_as_readable(options={})
+      class_attribute :readable_options
+
+      self.readable_options = options
+
+      has_many :read_marks, :as => :readable, :dependent => :delete_all
+
+      ReadMark.readable_classes ||= []
+      ReadMark.readable_classes << self unless ReadMark.readable_classes.include?(self)
+
+      include Readable::InstanceMethods
+      extend Readable::ClassMethods
+      extend Readable::Scopes
+    end
+  end
+end

data/lib/unread_mongoid/read_mark.rb

@@ -0,0 +1,21 @@
+class ReadMark
+  include Mongoid::Document
+
+  field :timestamp, type: Time
+
+  belongs_to :readable, :polymorphic => true
+  belongs_to :user
+
+  validates_presence_of :user_id, :readable_type
+
+  scope :global, -> { where(:readable_id => nil) }
+  scope :single, -> { ne(readable_id: nil) }
+  scope :older_than, -> (timestamp) { lt(timestamp: timestamp) }
+
+  # Returns the class defined by acts_as_reader
+  def self.reader_class
+    reflect_on_all_associations(:belongs_to).find { |assoc| assoc.name == :user }.try(:klass)
+  end
+
+  class_attribute :readable_classes
+end

data/lib/unread_mongoid/readable.rb

@@ -0,0 +1,117 @@
+module UnreadMongoid
+  module Readable
+    module ClassMethods
+      def mark_as_read!(target, options)
+        user = options[:for]
+        assert_reader(user)
+
+        if target == :all
+          reset_read_marks_for_user(user)
+        elsif target.is_a?(Array)
+          mark_array_as_read(target, user)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def mark_array_as_read(array, user)
+        array.each do |obj|
+          raise ArgumentError unless obj.is_a?(self)
+
+          rm = obj.read_marks.where(user_id: user._id).first || obj.read_marks.build(user_id: user._id)
+          rm.timestamp = obj.send(readable_options[:on])
+          rm.save!
+        end
+      end
+
+      # A scope with all items accessable for the given user
+      # It's used in cleanup_read_marks! to support a filtered cleanup
+      # Should be overriden if a user doesn't have access to all items
+      # Default: User has access to all items and should read them all
+      #
+      # Example:
+      #   def Message.read_scope(user)
+      #     user.visible_messages
+      #   end
+      def read_scope(user)
+        self
+      end
+
+      def cleanup_read_marks!
+        assert_reader_class
+
+        ReadMark.reader_class.each do |user|
+          if oldest_timestamp = read_scope(user).unread_by(user).sort(readable_options[:on] => :asc).first.send(readable_options[:on])
+            # There are unread items, so update the global read_mark for this user to the oldest
+            # unread item and delete older read_marks
+            update_read_marks_for_user(user, oldest_timestamp)
+          else
+            # There is no unread item, so deletes all markers and move global timestamp
+            reset_read_marks_for_user(user)
+          end
+        end
+      end
+
+      def update_read_marks_for_user(user, timestamp)
+        # Delete markers OLDER than the given timestamp
+        user.read_marks.where(:readable_type => self.name).single.older_than(timestamp).delete_all
+
+        # Change the global timestamp for this user
+        rm = user.read_mark_global(self) || user.read_marks.build(:readable_type => self.name)
+        rm.timestamp = timestamp - 1.second
+        rm.save!
+      end
+
+      def reset_read_marks_for_all
+        ReadMark.delete_all :readable_type => self.name
+        ReadMark.reader_class.each do |user|
+          ReadMark.create!(user_id: user._id, readable_type: self.name, timestamp: Time.current.to_s(:db))
+        end
+      end
+
+      def reset_read_marks_for_user(user)
+        assert_reader(user)
+
+        ReadMark.delete_all :readable_type => self.name, :user_id => user._id
+        ReadMark.create!    :readable_type => self.name, :user_id => user._id, :timestamp => Time.now
+      end
+
+      def assert_reader(user)
+        assert_reader_class
+
+        unless user.is_a?(ReadMark.reader_class)
+          raise ArgumentError, "Class #{user.class.name} is not registered by acts_as_reader!"
+        end
+
+        unless user._id
+          raise ArgumentError, "The given user has no id!"
+        end
+      end
+
+      def assert_reader_class
+        raise RuntimeError, 'There is no class using acts_as_reader!' unless ReadMark.reader_class
+      end
+    end
+
+    module InstanceMethods
+      def unread?(user)
+        self.class.unread_by(user).and(_id: self._id).exists?
+      end
+
+      def mark_as_read!(options)
+        user = options[:for]
+        self.class.assert_reader(user)
+
+        if unread?(user)
+          rm = read_mark(user) || read_marks.build(:user_id => user._id)
+          rm.timestamp = self.send(readable_options[:on]).to_s(:db)
+          rm.save!
+        end
+      end
+
+      def read_mark(user)
+        read_marks.where(:user_id => user._id).first
+      end
+    end
+  end
+end

data/lib/unread_mongoid/reader.rb

@@ -0,0 +1,15 @@
+module UnreadMongoid
+  module Reader
+    module InstanceMethods
+      def read_mark_global(klass)
+        instance_var_name = "@read_mark_global_#{klass.name.gsub('::','_')}"
+        if instance_variables.include?(instance_var_name.to_sym)
+          instance_variable_get(instance_var_name)
+        else # memoize
+          obj = self.read_marks.where(:readable_type => klass.name).global.first
+          instance_variable_set(instance_var_name, obj)
+        end
+      end
+    end
+  end
+end

data/lib/unread_mongoid/scopes.rb

@@ -0,0 +1,44 @@
+module UnreadMongoid
+  module Readable
+    module Scopes
+      # TODO rename some of these
+
+      def unread_by(user)
+        self.not_in(_id: read_ids(user))
+      end
+
+      def read_by(user)
+        self.in(_id: read_ids(user))
+      end
+
+      private
+      def read_marks_query(user)
+        assert_reader(user)
+
+        ReadMark.where(readable_type: self.name, user_id: user._id)
+      end
+
+      def blanket_marks_query(user)
+        read_marks_query(user).and(readable_id: nil).sort(timestamp: :desc)
+      end
+
+      def read_ids(user)
+        specifically_marked_ids(user) + blanketed_ids(user)
+      end
+
+      def blanketed_ids(user)
+        blanket = blanket_marks_query(user).first
+
+        if blanket
+          self.lte(self.readable_options[:on] => blanket.timestamp).only(:_id).map(&:_id)
+        else
+          []
+        end
+      end
+
+      def specifically_marked_ids(user)
+        read_marks_query(user).ne(readable_id: nil).only(:readable_id).map(&:readable_id)
+      end
+    end
+  end
+end

data/lib/unread_mongoid/version.rb

@@ -0,0 +1,3 @@
+module UnreadMongoid
+  VERSION = '0.0.1'
+end

data/lib/unread_mongoid.rb

@@ -0,0 +1,7 @@
+require 'mongoid'
+require 'unread_mongoid/base'
+require 'unread_mongoid/read_mark'
+require 'unread_mongoid/readable'
+require 'unread_mongoid/reader'
+require 'unread_mongoid/scopes'
+require 'unread_mongoid/version'

data/test/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: mongoid
+      hosts:
+        - localhost:27017

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'mongoid'
+require 'timecop'
+
+ENV['MONGOID_ENV'] = 'test'
+Mongoid.load!(File.dirname(__FILE__) + '/mongoid.yml')
+
+require 'unread_mongoid'
+
+class Reader
+  include Mongoid::Document
+  include UnreadMongoid
+
+  acts_as_reader
+
+  field :name, type: String
+end
+
+class Email
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  include UnreadMongoid
+
+  acts_as_readable :on => :updated_at
+
+  field :subject, type: String
+  field :content, type: String
+end
+
+puts "Testing with Mongoid #{Mongoid::VERSION}"

data/test/unread_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+
+class UnreadTest < ActiveSupport::TestCase
+  def setup
+    @reader = Reader.create! :name => 'David'
+    @other_reader = Reader.create :name => 'Matz'
+
+    wait
+    @email1 = Email.create!
+    wait
+    @email2 = Email.create!
+  end
+
+  def teardown
+    Reader.delete_all
+    Email.delete_all
+    ReadMark.delete_all
+    Timecop.return
+  end
+
+  def test_schema_has_loaded_correctly
+    assert_equal [@email1, @email2], Email.all
+  end
+
+  def test_readable_classes
+    assert_equal [ Email ], ReadMark.readable_classes
+  end
+
+  def test_reader_class
+    assert_equal Reader, ReadMark.reader_class
+  end
+
+  def test_scope
+    assert_equal [@email1, @email2], Email.unread_by(@reader)
+    assert_equal [@email1, @email2], Email.unread_by(@other_reader)
+
+    assert_equal 2, Email.unread_by(@reader).count
+    assert_equal 2, Email.unread_by(@other_reader).count
+  end
+
+  def test_read_by
+    @email1.mark_as_read! :for => @reader
+
+    assert_equal [@email1], Email.read_by(@reader).entries
+  end
+
+  #def test_with_read_marks_for
+    #@email1.mark_as_read! :for => @reader
+
+    #emails = Email.with_read_marks_for(@reader).entries
+
+    #assert emails[0].read_mark_id.present?
+    #assert emails[1].read_mark_ids.nil?
+
+    #assert_equal false, emails[0].unread?(@reader)
+    #assert_equal true, emails[1].unread?(@reader)
+  #end
+
+  def test_scope_param_check
+    [ 42, nil, 'foo', :foo, {} ].each do |not_a_reader|
+      assert_raise(ArgumentError) { Email.unread_by(not_a_reader) }
+      assert_raise(ArgumentError) { Email.read_by(not_a_reader) }
+    end
+
+    # gonna keep this, but not really likely in mongoid
+    unsaved_reader = Reader.new
+    unsaved_reader._id = nil
+
+    assert_raise(ArgumentError) { Email.unread_by(unsaved_reader) }
+    assert_raise(ArgumentError) { Email.read_by(unsaved_reader) }
+  end
+
+  def test_scope_after_reset
+    @email1.mark_as_read! :for => @reader
+
+    assert_equal [@email2], Email.unread_by(@reader)
+    assert_equal 1, Email.unread_by(@reader).count
+  end
+
+  def test_unread_after_create
+    assert_equal true, @email1.unread?(@reader)
+    assert_equal true, @email1.unread?(@other_reader)
+
+    assert_raise(ArgumentError) {
+      @email1.unread?(42)
+    }
+  end
+
+  def test_unread_after_update
+    @email1.mark_as_read! :for => @reader
+    wait
+    @email1.update_attributes! :subject => 'changed'
+
+    assert_equal true, @email1.unread?(@reader)
+  end
+
+  def test_mark_as_read
+    @email1.mark_as_read!(:for => @reader)
+
+    assert_equal false, @email1.unread?(@reader)
+    assert_equal [@email2], Email.unread_by(@reader).entries
+
+    assert_equal true, @email1.unread?(@other_reader)
+    assert_equal [@email1, @email2], Email.unread_by(@other_reader).entries
+
+    assert_equal 1, @reader.read_marks.single.count
+    assert_equal @email1, @reader.read_marks.single.first.readable
+  end
+
+  def test_mark_as_read_multiple
+    assert_equal true, @email1.unread?(@reader)
+    assert_equal true, @email2.unread?(@reader)
+
+    Email.mark_as_read! [ @email1, @email2 ], :for => @reader
+
+    assert_equal false, @email1.unread?(@reader)
+    assert_equal false, @email2.unread?(@reader)
+  end
+
+  def test_mark_as_read_with_marked_all
+    wait
+
+    Email.mark_as_read! :all, :for => @reader
+    @email1.mark_as_read! :for => @reader
+
+    assert_equal [], @reader.read_marks.single.entries
+  end
+
+  def test_mark_as_read_twice
+    @email1.mark_as_read! :for => @reader
+    @email1.mark_as_read! :for => @reader
+
+    assert_equal 1, @reader.read_marks.single.count
+  end
+
+  def test_mark_all_as_read
+    Email.mark_as_read! :all, :for => @reader
+
+    assert_equal Time.current, @reader.read_mark_global(Email).timestamp
+    assert_equal [], @reader.read_marks.single
+    assert_equal 0, ReadMark.single.count
+    assert_equal 2, ReadMark.global.count
+  end
+
+  def test_cleanup_read_marks
+    assert_equal 0, @reader.read_marks.single.count
+
+    @email1.mark_as_read! :for => @reader
+
+    assert_equal [@email2], Email.unread_by(@reader).entries
+    assert_equal 1, @reader.read_marks.single.count
+
+    Email.cleanup_read_marks!
+
+    @reader.reload
+    assert_equal 0, @reader.read_marks.single.count
+  end
+
+  def test_cleanup_read_marks_not_delete_from_other_readables
+    other_read_mark = @reader.read_marks.create! :readable_type => 'Foo', :readable_id => 42, :timestamp => 5.years.ago
+    Email.cleanup_read_marks!
+    assert_equal true, ReadMark.where(_id: other_read_mark._id).exists?
+  end
+
+  def test_reset_read_marks_for_all
+    Email.reset_read_marks_for_all
+
+    assert_equal 0, ReadMark.single.count
+    assert_equal 2, ReadMark.global.count
+  end
+
+private
+  def wait
+    Timecop.freeze(1.minute.from_now.change(:usec => 0))
+  end
+end

data/unread_mongoid.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "unread_mongoid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "unread-mongoid"
+  s.version     = UnreadMongoid::VERSION
+  s.authors     = ["Hunter Haydel", "Georg Ledermann"]
+  s.email       = ["haydh530@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Manages read/unread status of Mongoid objects}
+  s.description = %q{This gem creates a scope for unread objects and adds methods to mark objects as read }
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'mongoid', '~> 3.1.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'timecop'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: unread-mongoid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hunter Haydel
+- Georg Ledermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'This gem creates a scope for unread objects and adds methods to mark
+  objects as read '
+email:
+- haydh530@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- changelog.md
+- lib/generators/unread/migration/migration_generator.rb
+- lib/generators/unread/migration/templates/migration.rb
+- lib/unread_mongoid.rb
+- lib/unread_mongoid/base.rb
+- lib/unread_mongoid/read_mark.rb
+- lib/unread_mongoid/readable.rb
+- lib/unread_mongoid/reader.rb
+- lib/unread_mongoid/scopes.rb
+- lib/unread_mongoid/version.rb
+- test/mongoid.yml
+- test/test_helper.rb
+- test/unread_test.rb
+- unread_mongoid.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Manages read/unread status of Mongoid objects
+test_files:
+- test/mongoid.yml
+- test/test_helper.rb
+- test/unread_test.rb