unread-mongoid 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8ad50fe8b295cea62aca80e1fc08fa149caeb5d
-  data.tar.gz: 6612008cbf7da7497baa6591ccbfc551e6baa9d0
+  metadata.gz: 1cd035eab063883dddcbb6f3e99398b4dc5346d7
+  data.tar.gz: e18f414642a5cd38eea6fd8a55cbc2fdf2c0606e
 SHA512:
-  metadata.gz: 64d9d12c0183503a7a5a441941cd6309b45104ee5dc7d3c68972d20ae53a67bba740ee28bc546b8783d53f13d99bbd0a7a5ef6fc6b8bd8e0e7d6da62f6b88435
-  data.tar.gz: 2afd84b2942c203d23951e9d363c880d1ef9eefd6092845d469abc1837338197ee640a98bfea9995da8e45401a88455050684db273e8943ad53c047ce6f37834
+  metadata.gz: e0c977d07ba535824213afc3ac6b511120ee2cf7700aedd4f56f6596be3a2cc5c79022d835568ea29090fd364720fb1de507b33ef5208cba821968e5e6be6467
+  data.tar.gz: 9887a638a534ce31d9a6261f93f59b58e85f537d31ab14615f6c9434fa41a7c8402fd120e86fab5a7d38dbef0b026a897b67eebed724ce7b2720c018eca19bbb

data/README.md

@@ -4,39 +4,16 @@ 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 reccomend you use his gem, this is a task much better suited to a relational db.
+First and foremost this is a fork of [Unread](https://github.com/ledermann/unread) by [Georg Ledermann](http://www.georg-ledermann.de). If you are using a relational DB, make sure to check it out.
 
 ## 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
+* Supports _mark all as read_ to mark **all** records (loops through creating a readmark for each)
 * 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
@@ -52,7 +29,7 @@ class Message
   include Mongoid::Timestamps
 
   include UnreadMongoid
-  acts_as_readable :on => :created_at
+  acts_as_readable
 end
 
 message1 = Message.create!
@@ -69,8 +46,4 @@ Message.unread_by(current_user).entries
 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/lib/unread_mongoid/base.rb

@@ -5,31 +5,17 @@ module UnreadMongoid
 
   module Base
     def acts_as_reader
-      ReadMark.belongs_to :user, :class_name => self.to_s
+      has_many :read_marks, as: :reader, dependent: :destroy
 
-      has_many :read_marks, :dependent => :destroy, :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
+      include Reader
     end
 
-    def acts_as_readable(options={})
-      class_attribute :readable_options
+    def acts_as_readable
+      has_many :read_marks, as: :readable, dependent: :destroy
 
-      self.readable_options = options
-
-      has_many :read_marks, :as => :readable, :dependent => :destroy
-
-      ReadMark.readable_classes ||= []
-      ReadMark.readable_classes << self unless ReadMark.readable_classes.include?(self)
+      before_save do |readable|
+        readable.mark_as_unread!
+      end
 
       include Readable::InstanceMethods
       extend Readable::ClassMethods

data/lib/unread_mongoid/read_mark.rb

@@ -1,21 +1,9 @@
 class ReadMark
   include Mongoid::Document
 
-  field :timestamp, type: Time
+  belongs_to :readable, polymorphic: true, index: true
+  belongs_to :reader, polymorphic: true, index: true
 
-  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
+  validates_presence_of :reader_id, :reader_type, :readable_id, :readable_type
+  validates :reader_id, uniqueness: { scope: [:reader_type, :readable_id, :readable_type] }
 end

data/lib/unread_mongoid/readable.rb

@@ -2,115 +2,39 @@ module UnreadMongoid
   module Readable
     module ClassMethods
       def mark_as_read!(target, options)
-        user = options[:for]
-        assert_reader(user)
+        reader = options[:for]
+        UnreadMongoid::Reader.assert_reader(reader)
 
-        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
+        readables_to_mark = if(target == :all)
+                              self.unread_by(reader)
+                            else
+                              target
+                            end
 
-        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
+        self.unread_by(reader).each do |readable|
+          raise ArgumentError unless readable.is_a? self
 
-      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))
+          readable.mark_as_read! :for => reader
         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?
+      def unread?(reader)
+        UnreadMongoid::Reader.assert_reader(reader)
+
+        ReadMark.where(reader: reader, readable: self).empty?
       end
 
       def mark_as_read!(options)
-        user = options[:for]
-        self.class.assert_reader(user)
+        reader = options[:for]
+        UnreadMongoid::Reader.assert_reader(reader)
 
-        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
+        ReadMark.create(reader: reader, readable: self)
       end
 
-      def read_mark(user)
-        read_marks.where(:user_id => user._id).first
+      def mark_as_unread!
+        self.read_marks.destroy_all
       end
     end
   end

data/lib/unread_mongoid/reader.rb

@@ -1,14 +1,8 @@
 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
+    def self.assert_reader(obj)
+      unless obj.kind_of?(UnreadMongoid::Reader)
+        raise ArgumentError, "Class #{obj.class.name} is not registered by acts_as_reader!"
       end
     end
   end

data/lib/unread_mongoid/scopes.rb

@@ -1,45 +1,25 @@
 module UnreadMongoid
   module Readable
     module Scopes
-      # TODO rename some of these
+      def unread_by(reader)
+        UnreadMongoid::Reader.assert_reader(reader)
 
-      def unread_by(user)
-        self.not_in(_id: read_ids(user))
+        self.not_in(id: read_ids(reader))
       end
 
-      def read_by(user)
-        self.in(_id: read_ids(user))
-      end
-
-      private
-      def read_marks_query(user)
-        assert_reader(user)
+      def read_by(reader)
+        UnreadMongoid::Reader.assert_reader(reader)
 
-        ReadMark.where(readable_type: self.name, user_id: user._id)
+        self.in(id: read_ids(reader))
       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).select do |read_mark|
-          read_mark.timestamp.to_i >= read_mark.readable.send(self.readable_options[:on]).to_i
-        end.map(&:readable_id)
+      private
+      def read_ids(reader)
+        ReadMark.where(
+          reader_id: reader.id,
+          reader_type: reader.class.name,
+          readable_type: self.name
+        ).only(:readable_id).map(&:readable_id)
       end
     end
   end

data/lib/unread_mongoid/version.rb

@@ -1,3 +1,3 @@
 module UnreadMongoid
-  VERSION = '0.0.5'
+  VERSION = '0.1.0'
 end

data/test/test_helper.rb

@@ -7,7 +7,7 @@ Mongoid.load!(File.dirname(__FILE__) + '/mongoid.yml')
 
 require 'unread_mongoid'
 
-class Reader
+class User
   include Mongoid::Document
   include UnreadMongoid
 
@@ -22,7 +22,7 @@ class Email
 
   include UnreadMongoid
 
-  acts_as_readable :on => :updated_at
+  acts_as_readable
 
   field :subject, type: String
   field :content, type: String

data/test/unread_test.rb

@@ -2,8 +2,8 @@ require 'test_helper'
 
 class UnreadTest < ActiveSupport::TestCase
   def setup
-    @reader = Reader.create! :name => 'David'
-    @other_reader = Reader.create :name => 'Matz'
+    @reader = User.create! :name => 'David'
+    @other_reader = User.create :name => 'Matz'
 
     wait
     @email1 = Email.create!
@@ -12,24 +12,12 @@ class UnreadTest < ActiveSupport::TestCase
   end
 
   def teardown
-    Reader.delete_all
+    User.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)
@@ -44,36 +32,17 @@ class UnreadTest < ActiveSupport::TestCase
     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 [@email2], Email.unread_by(@reader).entries
     assert_equal 1, Email.unread_by(@reader).count
   end
 
@@ -102,9 +71,6 @@ class UnreadTest < ActiveSupport::TestCase
 
     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
@@ -117,64 +83,68 @@ class UnreadTest < ActiveSupport::TestCase
     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
+    assert_equal 1, ReadMark.where(reader: @reader).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
+    assert_equal [], Email.unread_by(@reader)
   end
 
-  def test_cleanup_read_marks
-    assert_equal 0, @reader.read_marks.single.count
+  def test_destroys_readmarks_when_readable_is_destroyed
+    @email1.mark_as_read! for: @reader
+
+    assert_equal 1, ReadMark.count
 
-    @email1.mark_as_read! :for => @reader
+    @email1.destroy
 
-    assert_equal [@email2], Email.unread_by(@reader).entries
-    assert_equal 1, @reader.read_marks.single.count
+    assert_equal 0, ReadMark.count
+  end
 
-    Email.cleanup_read_marks!
+  def test_destroys_readmarks_when_reader_is_destroyed
+    @email1.mark_as_read! for: @reader
+
+    assert_equal 1, ReadMark.count
+
+    @reader.destroy
 
-    @reader.reload
-    assert_equal 0, @reader.read_marks.single.count
+    assert_equal 0, ReadMark.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?
+  def test_does_not_destroy_readable_when_readmark_is_destroyed
+    email_id = @email1.id
+
+    @email1.mark_as_read! for: @reader
+
+    ReadMark.destroy_all
+
+    assert_equal 0, ReadMark.count
+    assert_equal 1, Email.where(id: email_id).count
   end
 
-  def test_reset_read_marks_for_all
-    Email.reset_read_marks_for_all
+  def test_does_not_destroy_reader_when_readmark_is_destroyed
+    reader_id = @reader
+
+    @email1.mark_as_read! for: @reader
+
+    ReadMark.destroy_all
 
-    assert_equal 0, ReadMark.single.count
-    assert_equal 2, ReadMark.global.count
+    assert_equal 0, ReadMark.count
+    assert_equal 1, User.where(id: reader_id).count
   end
 
-  def test_destroys_readmarks_when_readable_is_destroyed
-    count = ReadMark.count
+  def test_mark_as_unread_sets_readable_back_to_unread
     @email1.mark_as_read! for: @reader
-    assert_equal count + 1, ReadMark.count
-    @email1.destroy
-    assert_equal count, ReadMark.count
+    assert_equal false, @email1.unread?(@reader)
+
+    @email1.mark_as_unread!
+
+    assert_equal true, @email1.unread?(@reader)
   end
 private
   def wait

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unread-mongoid
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Hunter Haydel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-21 00:00:00.000000000 Z
+date: 2014-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid