unread 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 641b3b24fbf159c92f7b4a29485b987454cd382f
-  data.tar.gz: 2aa121f6822aad813d903014bf3284b7323a8cbb
+  metadata.gz: f5498050ac28f45c15fb7fddd5bd1288bf773d68
+  data.tar.gz: 784de80f41de7112583dbc1586d3827830fc20cb
 SHA512:
-  metadata.gz: fd852349b8f7365896c4b2d35e88f18dd7cf3ce3275f52dc0b8c55a24334306d4a6cb22ac98d356d80b92588ebbe9b78d0cd9924785f7524a32055aec0d0c598
-  data.tar.gz: 80038ecb572e07cc0ca3e1e21ae4e2879f21d80d13d03c6d6c524a7000f0098bac258d5b3f142a71cbf20b384c80c3e579ea4e6e08c1228eba351aa6e7251a8c
+  metadata.gz: bf9a770272bfeb81435d347e8a8fafb4471b4e696f9d13a3a363cb82b9167c0d6d74c1422816bb50526dff6554cc104d936b54c2774a25b53e9b20ec48ba2b22
+  data.tar.gz: 5e6961f8caa78f6a3fabd24a9cdb220936eaf8b50a5c6af741c76224b96dfc1f9a4d726f005e40975513c2746f4dba6ebeaff3be9c90d7bc8c138811341240b2

data/README.md

@@ -3,10 +3,9 @@ Unread
 
 Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
-[![Build Status](https://travis-ci.org/ledermann/unread.png?branch=master)](https://travis-ci.org/ledermann/unread)
-[![Code Climate](https://codeclimate.com/github/ledermann/unread.png)](https://codeclimate.com/github/ledermann/unread)
-[![Coverage Status](https://coveralls.io/repos/ledermann/unread/badge.png)](https://coveralls.io/r/ledermann/unread)
-
+[![Build Status](https://travis-ci.org/ledermann/unread.svg?branch=master)](https://travis-ci.org/ledermann/unread)
+[![Code Climate](https://codeclimate.com/github/ledermann/unread.svg)](https://codeclimate.com/github/ledermann/unread)
+[![Coverage Status](https://coveralls.io/repos/ledermann/unread/badge.svg?branch=master)](https://coveralls.io/r/ledermann/unread?branch=master)
 
 ## Features
 
@@ -58,6 +57,10 @@ rake db:migrate
 ```ruby
 class User < ActiveRecord::Base
   acts_as_reader
+
+  # or, if only a subset of users are readers:
+  scope :admins, -> { where(:is_admin => true) }
+  acts_as_reader :scope => -> { admins }
 end
 
 class Message < ActiveRecord::Base
@@ -75,6 +78,14 @@ message1.mark_as_read! :for => current_user
 Message.unread_by(current_user)
 # => [ message2 ]
 
+## Get read messages for a given user
+Message.read_by(current_user)
+# => [ ]
+
+message1.mark_as_read! :for => current_user
+Message.read_by(current_user)
+# => [ message1 ]
+
 ## Get all messages including the read status for a given user
 messages = Message.with_read_marks_for(current_user)
 # => [ message1, message2 ]
@@ -87,8 +98,49 @@ Message.mark_as_read! :all, :for => current_user
 Message.unread_by(current_user)
 # => [ ]
 
-# Optional: Cleaning up unneeded markers.
-# Do this in a cron job once a day.
+Message.read_by(current_user)
+# => [ message1, message2 ]
+
+## Get users that have not read a given message
+user1 = User.create!
+user2 = User.create!
+
+User.have_not_read(message1)
+# => [ user1, user2 ]
+
+message1.mark_as_read! :for => user1
+User.have_not_read(message1)
+# => [ user2 ]
+
+## Get users that have read a given message
+User.have_read(message1)
+# => [ user1 ]
+
+message1.mark_as_read! :for => user2
+User.have_read(message1)
+# => [ user1, user2 ]
+
+Message.mark_as_read! :all, :for => user1
+User.have_not_read(message1)
+# => [ ]
+User.have_not_read(message2)
+# => [ user2 ]
+
+User.have_read(message1)
+# => [ user1, user2 ]
+User.have_read(message2)
+# => [ user1 ]
+
+## Get all users including their read status for a given message
+users = User.with_read_marks_for(message1)
+# => [ user1, user2 ]
+users[0].have_read?(message1)
+# => true
+users[1].have_read?(message2)
+# => false
+
+# Optional: Cleaning up unneeded markers
+# Do this in a cron job once a day
 Message.cleanup_read_marks!
 ```
 
@@ -119,7 +171,7 @@ Generated query:
 ```sql
 SELECT messages.*
 FROM messages
-LEFT JOIN read_marks ON read_marks.readable_type = 'Message'
+LEFT JOIN read_marks ON read_marks.readable_type = "Message"
                     AND read_marks.readable_id = messages.id
                     AND read_marks.user_id = 42
                     AND read_marks.timestamp >= messages.created_at
@@ -130,14 +182,4 @@ AND messages.created_at > '2010-10-20 08:50:00'
 Hint: You should add a database index on `messages.created_at`.
 
 
-## Similar tools
-
-There are two other gems/plugins doing a similar job:
-
-* http://github.com/jhnvz/mark_as_read
-* http://github.com/mbleigh/acts-as-readable
-
-Unfortunately, both of them have a lack of performance, because they calculate the unread records doing a `find(:all)`, which should be avoided for a large amount of records. This gem is based on a timestamp algorithm and therefore it's very fast.
-
-
 Copyright (c) 2010-2015 [Georg Ledermann](http://www.georg-ledermann.de), released under the MIT license

data/lib/unread.rb

@@ -2,7 +2,8 @@ require 'unread/base'
 require 'unread/read_mark'
 require 'unread/readable'
 require 'unread/reader'
-require 'unread/scopes'
+require 'unread/readable_scopes'
+require 'unread/reader_scopes'
 require 'unread/version'
 
 ActiveRecord::Base.send :include, Unread

data/lib/unread/base.rb

@@ -22,6 +22,8 @@ module Unread
       ReadMark.reader_options = options
 
       include Reader::InstanceMethods
+      extend Reader::ClassMethods
+      extend Reader::Scopes
     end
 
     def acts_as_readable(options={})

data/lib/unread/read_mark.rb

@@ -1,8 +1,5 @@
 class ReadMark < ActiveRecord::Base
   belongs_to :readable, :polymorphic => true
-  if ActiveRecord::VERSION::MAJOR < 4
-    attr_accessible :readable_id, :user_id, :readable_type, :timestamp
-  end
 
   validates_presence_of :user_id, :readable_type
 
@@ -10,7 +7,7 @@ class ReadMark < ActiveRecord::Base
   scope :single, lambda { where('readable_id IS NOT NULL') }
   scope :older_than, lambda { |timestamp| where([ 'timestamp < ?', timestamp ]) }
 
-  # Returns the class defined by acts_as_reader
+  # Returns the class and options defined by acts_as_reader
   class_attribute :reader_class
   class_attribute :reader_options
 
@@ -18,11 +15,6 @@ class ReadMark < ActiveRecord::Base
   class_attribute :readable_classes
 
   def self.reader_scope
-    result = reader_class
-
-    Array(reader_options[:scopes]).each do |scope|
-      result = result.send(scope)
-    end
-    result
+    reader_options[:scope].try(:call) || self
   end
 end

data/lib/unread/readable.rb

@@ -27,7 +27,8 @@ module Unread
             if global_timestamp && global_timestamp >= timestamp
               # The object is implicitly marked as read, so there is nothing to do
             else
-              rm = obj.read_marks.where(:user_id => user.id).first || obj.read_marks.build(:user_id => user.id)
+              rm = obj.read_marks.where(:user_id => user.id).first || obj.read_marks.build
+              rm.user_id   = user.id
               rm.timestamp = timestamp
               rm.save!
             end
@@ -52,36 +53,44 @@ module Unread
         assert_reader_class
 
         ReadMark.reader_scope.find_each do |user|
-          ReadMark.transaction do
-            if oldest_timestamp = read_scope(user).unread_by(user).minimum(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
+          if oldest_timestamp = read_scope(user).unread_by(user).minimum(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.base_class.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.base_class.name)
-        rm.timestamp = timestamp - 1.second
-        rm.save!
+        ReadMark.transaction do
+          # Delete markers OLDER than the given timestamp
+          user.read_marks.where(:readable_type => self.base_class.name).single.older_than(timestamp).delete_all
+
+          # Change the global timestamp for this user
+          rm = user.read_mark_global(self) || user.read_marks.build
+          rm.readable_type = self.base_class.name
+          rm.timestamp     = timestamp - 1.second
+          rm.save!
+        end
       end
 
       def reset_read_marks_for_all
         ReadMark.transaction do
           ReadMark.delete_all :readable_type => self.base_class.name
+
+          # Build a SELECT statement with all relevant readers
+          reader_sql = ReadMark.
+                         reader_scope.
+                         select("#{ReadMark.reader_scope.quoted_table_name}.#{ReadMark.reader_scope.quoted_primary_key},
+                                '#{self.base_class.name}',
+                                '#{connection.quoted_date Time.current}'").to_sql
+
           ReadMark.connection.execute <<-EOT
-            INSERT INTO #{ReadMark.table_name} (user_id, readable_type, timestamp)
-            SELECT #{ReadMark.reader_class.primary_key}, '#{self.base_class.name}', '#{Time.current.to_s(:db)}'
-            FROM #{ReadMark.reader_class.table_name}
+            INSERT INTO read_marks (user_id, readable_type, timestamp)
+            #{reader_sql}
           EOT
         end
       end
@@ -91,8 +100,15 @@ module Unread
 
         ReadMark.transaction do
           ReadMark.delete_all :readable_type => self.base_class.name, :user_id => user.id
-          ReadMark.create!    :readable_type => self.base_class.name, :user_id => user.id, :timestamp => Time.current
+
+          ReadMark.create! do |rm|
+            rm.readable_type = self.base_class.name
+            rm.user_id       = user.id
+            rm.timestamp     = Time.current
+          end
         end
+
+        user.forget_memoized_read_mark_global
       end
 
       def assert_reader(user)
@@ -109,7 +125,7 @@ module Unread
 
     module InstanceMethods
       def unread?(user)
-        if self.respond_to?(:read_mark_id)
+        if self.respond_to?(:read_mark_id) && read_mark_id_belongs_to?(user)
           # For use with scope "with_read_marks_for"
           return false if self.read_mark_id
 
@@ -129,7 +145,8 @@ module Unread
 
         ReadMark.transaction do
           if unread?(user)
-            rm = read_mark(user) || read_marks.build(:user_id => user.id)
+            rm = read_mark(user) || read_marks.build
+            rm.user_id   = user.id
             rm.timestamp = self.send(readable_options[:on])
             rm.save!
           end
@@ -139,6 +156,12 @@ module Unread
       def read_mark(user)
         read_marks.where(:user_id => user.id).first
       end
+
+      private
+
+      def read_mark_id_belongs_to?(user)
+        self.read_mark_user_id == user.id
+      end
     end
   end
 end

data/lib/unread/readable_scopes.rb

@@ -0,0 +1,47 @@
+module Unread
+  module Readable
+    module Scopes
+      def join_read_marks(user)
+        assert_reader(user)
+
+        joins "LEFT JOIN read_marks
+                ON read_marks.readable_type  = '#{base_class.name}'
+               AND read_marks.readable_id    = #{quoted_table_name}.#{quoted_primary_key}
+               AND read_marks.user_id        = #{user.id}
+               AND read_marks.timestamp     >= #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])}"
+      end
+
+      def unread_by(user)
+        result = join_read_marks(user)
+
+        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
+          result = result.where("read_marks.id IS NULL
+                                 AND #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])} > ?", global_time_stamp)
+        else
+          result = result.where('read_marks.id IS NULL')
+        end
+
+        result
+      end
+
+      def read_by(user)
+        result = join_read_marks(user)
+
+        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
+          result = result.where("read_marks.id IS NOT NULL
+                                 OR #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])} <= ?", global_time_stamp)
+        else
+          result = result.where('read_marks.id IS NOT NULL')
+        end
+
+        result
+      end
+
+      def with_read_marks_for(user)
+        join_read_marks(user).select("#{quoted_table_name}.*,
+                                     read_marks.id AS read_mark_id,
+                                     #{user.id} AS read_mark_user_id")
+      end
+    end
+  end
+end

data/lib/unread/reader.rb

@@ -1,15 +1,45 @@
 module Unread
   module Reader
+    module ClassMethods
+      def assert_readable(readable)
+        assert_readable_class
+
+        unless ReadMark.readable_classes.include?(readable.class)
+          raise ArgumentError, "Class #{readable.class.name} is not registered by acts_as_readable."
+        end
+        raise ArgumentError, "The given #{readable.class.name} has no id." unless readable.id
+      end
+
+      def assert_readable_class
+        raise RuntimeError, 'There is no class using acts_as_readable.' unless ReadMark.readable_classes.try(:any?)
+      end
+    end
+
     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.base_class.name).global.first
-          instance_variable_set(instance_var_name, obj)
+        @read_mark_global ||= {}
+        @read_mark_global[klass] ||= read_marks.where(:readable_type => klass.base_class.name).global.first
+      end
+
+      def forget_memoized_read_mark_global
+        @read_mark_global = nil
+      end
+
+      def have_read?(readable)
+        if self.respond_to?(:read_mark_id) && read_mark_id_belongs_to?(readable)
+          # For use with scope "with_read_marks_for"
+          !self.read_mark_id.nil?
+        else
+          !self.class.have_not_read(readable).exists?(self.id)
         end
       end
+
+      private
+
+      def read_mark_id_belongs_to?(readable)
+        self.read_mark_readable_type == readable.class.base_class.name &&
+        (self.read_mark_readable_id.nil? || self.read_mark_readable_id == readable.id)
+      end
     end
   end
 end

data/lib/unread/reader_scopes.rb

@@ -0,0 +1,29 @@
+module Unread
+  module Reader
+    module Scopes
+      def join_read_marks(readable)
+        assert_readable(readable)
+
+        joins "LEFT JOIN read_marks
+                ON read_marks.readable_type  = '#{readable.class.base_class.name}'
+               AND (read_marks.readable_id   = #{readable.id} OR read_marks.readable_id IS NULL)
+               AND read_marks.user_id        = #{quoted_table_name}.#{quoted_primary_key}
+               AND read_marks.timestamp     >= '#{connection.quoted_date readable.send(readable.class.readable_options[:on])}'"
+      end
+
+      def have_not_read(readable)
+        join_read_marks(readable).where("read_marks.id IS NULL")
+      end
+
+      def have_read(readable)
+        join_read_marks(readable).where('read_marks.id IS NOT NULL')
+      end
+
+      def with_read_marks_for(readable)
+        join_read_marks(readable).select("#{quoted_table_name}.*, read_marks.id AS read_mark_id,
+                                         '#{readable.class.base_class.name}' AS read_mark_readable_type,
+                                          #{readable.id} AS read_mark_readable_id")
+      end
+    end
+  end
+end

data/lib/unread/version.rb

@@ -1,3 +1,3 @@
 module Unread
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/spec/base_spec.rb

@@ -20,6 +20,13 @@ describe Unread::Base do
     it "should reset read_marks for created reader" do
       expect(Email.unread_by(@reader)).to be_empty
     end
+
+    it "should memoize read_mark_global" do
+      expect {
+        rm1 = @reader.read_mark_global(Email)
+        rm2 = @reader.read_mark_global(Email)
+      }.to perform_queries(1)
+    end
   end
 
   describe :acts_as_readable do

data/spec/model/reader.rb

@@ -4,5 +4,5 @@ class Reader < ActiveRecord::Base
   scope :not_foo, -> { where('name <> "foo"') }
   scope :not_bar, -> { where('name <> "bar"') }
 
-  acts_as_reader :scopes => [:not_foo, :not_bar]
+  acts_as_reader :scope => -> { not_foo.not_bar }
 end

data/spec/read_mark_spec.rb

@@ -8,4 +8,8 @@ describe ReadMark do
   it "should have reader_scope" do
     expect(ReadMark.reader_scope).to eq Reader.not_foo.not_bar
   end
+
+  it "should have readable_classes" do
+    expect(ReadMark.readable_classes).to eq [Email]
+  end
 end

data/spec/readable_spec.rb

@@ -21,6 +21,8 @@ describe Unread::Readable do
 
       expect(Email.unread_by(@reader)).to eq [@email2]
       expect(Email.unread_by(@reader).count).to eq 1
+
+      expect(Email.unread_by(@other_reader)).to eq [@email1, @email2]
     end
 
     it "should not allow invalid parameter" do
@@ -38,8 +40,119 @@ describe Unread::Readable do
         Email.unread_by(unsaved_reader)
       }.to raise_error(ArgumentError)
     end
+
+    describe "should work without any read_marks" do
+      before do
+        ReadMark.delete_all
+      end
+
+      it "should return all objects" do
+        expect(Email.unread_by(@reader)).to eq [@email1, @email2]
+        expect(Email.unread_by(@other_reader)).to eq [@email1, @email2]
+      end
+
+      it "should return unread records" do
+        @email1.mark_as_read! :for => @reader
+
+        expect(Email.unread_by(@reader)).to eq [@email2]
+        expect(Email.unread_by(@reader).count).to eq 1
+      end
+
+      it "should not allow invalid parameter" do
+        [ 42, nil, 'foo', :foo, {} ].each do |not_a_reader|
+          expect {
+            Email.unread_by(not_a_reader)
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      it "should not allow unsaved reader" do
+        unsaved_reader = Reader.new
+
+        expect {
+          Email.unread_by(unsaved_reader)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe :read_by do
+    it "should return an empty array" do
+      expect(Email.read_by(@reader)).to be_empty
+      expect(Email.read_by(@other_reader)).to be_empty
+    end
+
+    it "should return read records" do
+      @email1.mark_as_read! :for => @reader
+
+      expect(Email.read_by(@reader)).to eq [@email1]
+      expect(Email.read_by(@reader).count).to eq 1
+    end
+
+    it "should return all records when all read" do
+      Email.mark_as_read! :all, :for => @reader
+
+      expect(Email.read_by(@reader)).to eq [@email1, @email2]
+    end
+
+    it "should not allow invalid parameter" do
+      [ 42, nil, 'foo', :foo, {} ].each do |not_a_reader|
+        expect {
+          Email.read_by(not_a_reader)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "should not allow unsaved reader" do
+      unsaved_reader = Reader.new
+
+      expect {
+        Email.read_by(unsaved_reader)
+      }.to raise_error(ArgumentError)
+    end
+
+    describe "should work without any read_marks" do
+      before do
+        ReadMark.delete_all
+      end
+
+      it "should return an empty array" do
+        expect(Email.read_by(@reader)).to be_empty
+        expect(Email.read_by(@other_reader)).to be_empty
+      end
+
+      it "should return read records" do
+        @email1.mark_as_read! :for => @reader
+
+        expect(Email.read_by(@reader)).to eq [@email1]
+        expect(Email.read_by(@reader).count).to eq 1
+      end
+
+      it "should return all records when all read" do
+        Email.mark_as_read! :all, :for => @reader
+
+        expect(Email.read_by(@reader)).to eq [@email1, @email2]
+      end
+
+      it "should not allow invalid parameter" do
+        [ 42, nil, 'foo', :foo, {} ].each do |not_a_reader|
+          expect {
+            Email.read_by(not_a_reader)
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      it "should not allow unsaved reader" do
+        unsaved_reader = Reader.new
+
+        expect {
+          Email.read_by(unsaved_reader)
+        }.to raise_error(ArgumentError)
+      end
+    end
   end
 
+
   describe :with_read_marks_for do
     it "should return readables" do
       expect(Email.with_read_marks_for(@reader).to_a).to eq([@email1, @email2])
@@ -97,6 +210,22 @@ describe Unread::Readable do
         expect(emails[1].unread?(@reader)).to be_truthy
       }.to perform_queries(1)
     end
+
+    it "should work without any read_marks" do
+      ReadMark.delete_all
+
+      emails = Email.with_read_marks_for(@reader).to_a
+      expect(emails[0].unread?(@reader)).to be_truthy
+      expect(emails[1].unread?(@reader)).to be_truthy
+    end
+
+    it "should work with eager-loaded read marks for the correct reader" do
+      @email1.mark_as_read! :for => @reader
+
+      emails = Email.with_read_marks_for(@reader).to_a
+      expect(emails[0].unread?(@reader)).to be_falsey
+      expect(emails[0].unread?(@other_reader)).to be_truthy
+    end
   end
 
   describe '#mark_as_read!' do
@@ -158,6 +287,13 @@ describe Unread::Readable do
       expect(@reader.read_marks.single).to eq []
     end
 
+    it "should reset memoized global read mark" do
+      rm_global = @reader.read_mark_global(Email)
+
+      Email.mark_as_read! :all, :for => @reader
+      expect(@reader.read_mark_global(Email)).not_to eq(rm_global)
+    end
+
     it "should not allow invalid arguments" do
       expect {
         Email.mark_as_read! :foo, :for => @reader
@@ -205,7 +341,12 @@ describe Unread::Readable do
     end
 
     it "should not delete read marks from other readables" do
-      other_read_mark = @reader.read_marks.create! :readable_type => 'Foo', :readable_id => 42, :timestamp => 5.years.ago
+      other_read_mark = @reader.read_marks.create! do |rm|
+        rm.readable_type = 'Foo'
+        rm.readable_id   = 42
+        rm.timestamp     = 5.years.ago
+      end
+
       Email.cleanup_read_marks!
 
       expect(ReadMark.exists?(other_read_mark.id)).to be_truthy

data/spec/reader_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Unread::Reader do
+  before :each do
+    @reader = Reader.create! :name => 'David'
+    @other_reader = Reader.create :name => 'Matz'
+    wait
+    @email1 = Email.create!
+    wait
+    @email2 = Email.create!
+  end
+
+  describe :have_not_read do
+    it "should return all readers that have not read a given object" do
+      expect(Reader.have_not_read(@email1)).to eq [@reader, @other_reader]
+      expect(Reader.have_not_read(@email2)).to eq [@reader, @other_reader]
+    end
+
+    it "should return *only* the readers that have not read a given object" do
+      @email1.mark_as_read! :for => @reader
+
+      expect(Reader.have_not_read(@email1)).to eq [@other_reader]
+      expect(Reader.have_not_read(@email1).count).to eq 1
+
+      expect(Reader.have_not_read(@email2)).to eq [@reader, @other_reader]
+    end
+
+    it "should not allow invalid parameter" do
+      [ 42, nil, 'foo', :foo, {} ].each do |not_a_readable|
+        expect {
+          Reader.have_not_read(not_a_readable)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "should not allow unsaved readable" do
+      unsaved_readable = Email.new
+
+      expect {
+        Reader.have_not_read(unsaved_readable)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :have_read do
+    it "should return an empty array" do
+      expect(Reader.have_read(@email1)).to be_empty
+      expect(Reader.have_read(@email2)).to be_empty
+    end
+
+    it "should return *only* the readers that have read the given object" do
+      @email1.mark_as_read! :for => @reader
+
+      expect(Reader.have_read(@email1)).to eq [@reader]
+      expect(Reader.have_read(@email1).count).to eq 1
+
+      expect(Reader.have_read(@email2)).to be_empty
+    end
+
+    it "should return the reader for all the object when all read" do
+      Email.mark_as_read! :all, :for => @reader
+
+      expect(Reader.have_read(@email1)).to eq [@reader]
+      expect(Reader.have_read(@email1).count).to eq 1
+
+      expect(Reader.have_read(@email2)).to eq [@reader]
+      expect(Reader.have_read(@email2).count).to eq 1
+    end
+
+    it "should not allow invalid parameter" do
+      [ 42, nil, 'foo', :foo, {} ].each do |not_a_readable|
+        expect {
+          Reader.have_read(not_a_readable)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "should not allow unsaved readable" do
+      unsaved_readable = Email.new
+
+      expect {
+        Reader.have_read(unsaved_readable)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :with_read_marks_for do
+    it "should return readers" do
+      expect(Reader.with_read_marks_for(@email1).to_a).to eq([@reader, @other_reader])
+    end
+
+    it "should have elements that respond to :read_mark_id" do
+      all_respond_to_read_mark_id = Reader.with_read_marks_for(@email1).to_a.all? do |reader|
+        reader.respond_to?(:read_mark_id)
+      end
+
+      expect(all_respond_to_read_mark_id).to be_truthy
+    end
+
+    it "should be countable" do
+      expect(Reader.with_read_marks_for(@email1).count(:number)).to eq(2)
+    end
+
+    it "should not allow invalid parameter" do
+      [ 42, nil, 'foo', :foo, {} ].each do |not_a_readable|
+        expect {
+          Reader.with_read_marks_for(not_a_readable)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "should not allow unsaved readable" do
+      unsaved_readable = Email.new
+
+      expect {
+        Reader.with_read_marks_for(unsaved_readable)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :have_read? do
+    it "should recognize read objects" do
+      expect(@reader.have_read?(@email1)).to be_falsey
+      expect(@reader.have_read?(@email2)).to be_falsey
+    end
+
+    it "should handle updating object" do
+      @email1.mark_as_read! :for => @reader
+      wait
+      expect(@reader.have_read?(@email1)).to be_truthy
+
+      @email1.update_attributes! :subject => 'changed'
+      expect(@reader.have_read?(@email1)).to be_falsey
+    end
+
+    it "should raise error for invalid argument" do
+      expect {
+        @reader.have_read?(42)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should work with eager-loaded read marks" do
+      @email1.mark_as_read! :for => @reader
+
+      expect {
+        readers = Reader.with_read_marks_for(@email1).to_a
+
+        expect(readers[0].have_read?(@email1)).to be_truthy
+        expect(readers[1].have_read?(@email1)).to be_falsey
+      }.to perform_queries(1)
+    end
+
+    it "should work with eager-loaded read marks for the correct readable" do
+      @email1.mark_as_read! :for => @reader
+
+      readers = Reader.with_read_marks_for(@email1).to_a
+      expect(readers[0].have_read?(@email1)).to be_truthy
+      expect(readers[0].have_read?(@email2)).to be_falsey
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -40,6 +40,10 @@ RSpec.configure do |config|
   config.after :each do
     Timecop.return
   end
+
+  config.after :suite do
+    UnreadMigration.migrate(:down)
+  end
 end
 
 if I18n.respond_to?(:enforce_available_locales=)

data/unread.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'simplecov'
-  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'coveralls', '>= 0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unread
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Georg Ledermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-14 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
 description: 'This gem creates a scope for unread objects and adds methods to mark
   objects as read '
 email:
@@ -134,14 +134,16 @@ files:
 - lib/unread/base.rb
 - lib/unread/read_mark.rb
 - lib/unread/readable.rb
+- lib/unread/readable_scopes.rb
 - lib/unread/reader.rb
-- lib/unread/scopes.rb
+- lib/unread/reader_scopes.rb
 - lib/unread/version.rb
 - spec/base_spec.rb
 - spec/model/email.rb
 - spec/model/reader.rb
 - spec/read_mark_spec.rb
 - spec/readable_spec.rb
+- spec/reader_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers/perform_queries.rb
 - spec/support/query_counter.rb
@@ -166,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: unread
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Manages read/unread status of ActiveRecord objects
@@ -176,6 +178,7 @@ test_files:
 - spec/model/reader.rb
 - spec/read_mark_spec.rb
 - spec/readable_spec.rb
+- spec/reader_spec.rb
 - spec/spec_helper.rb
 - spec/support/matchers/perform_queries.rb
 - spec/support/query_counter.rb

data/lib/unread/scopes.rb

@@ -1,29 +0,0 @@
-module Unread
-  module Readable
-    module Scopes
-      def join_read_marks(user)
-        assert_reader(user)
-
-        joins "LEFT JOIN #{ReadMark.table_name} as read_marks ON read_marks.readable_type  = '#{base_class.name}'
-                                   AND read_marks.readable_id    = #{table_name}.#{primary_key}
-                                   AND read_marks.user_id        = #{user.id}
-                                   AND read_marks.timestamp     >= #{table_name}.#{readable_options[:on]}"
-      end
-
-      def unread_by(user)
-        result = join_read_marks(user).
-                 where('read_marks.id IS NULL')
-
-        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
-          result = result.where("#{table_name}.#{readable_options[:on]} > '#{global_time_stamp.to_s(:db)}'")
-        end
-
-        result
-      end
-
-      def with_read_marks_for(user)
-        join_read_marks(user).select("#{table_name}.*, read_marks.id AS read_mark_id")
-      end
-    end
-  end
-end