unread 0.0.7 → 0.1.0

data/README.md

@@ -71,6 +71,7 @@ Step 2: Add this migration:
     message1 = Message.create!
     message2 = Message.create!
     
+    ## Get unread messages for a given user
     Message.unread_by(current_user)
     # => [ message1, message2 ]
     
@@ -78,6 +79,14 @@ Step 2: Add this migration:
     Message.unread_by(current_user)
     # => [ message2 ]
     
+    ## Get all messages including the read status for a given user
+    messages = Message.with_read_marks_for(current_user)
+    # => [ message1, message2 ]
+    messages[0].unread?(current_user)
+    # => false
+    messages[1].unread?(current_user)
+    # => true
+    
     Message.mark_as_read! :all, :for => current_user
     Message.unread_by(current_user)
     # => [ ]

data/changelog.md

@@ -1,4 +1,9 @@
-0.0.7 - not yet released
+0.1.0 - 2012/04/21
+
+* Added scope "with_read_marks_for"
+* Fixed #7: Added attr_accessible to all ReadMark attributes (thanks to @negative)
+
+0.0.7 - 2012/02/29
 
 * Cleanup files
 * acts_as_reader: Using inverse_of (available since Rails 2.3.6)

data/lib/app/models/read_mark.rb

@@ -1,5 +1,6 @@
 class ReadMark < ActiveRecord::Base
   belongs_to :readable, :polymorphic => true
+  attr_accessible :readable_id, :user_id, :readable_type, :timestamp
   
   validates_presence_of :user_id, :readable_type
   

data/lib/unread/acts_as_readable.rb

@@ -14,6 +14,8 @@ module Unread
           klass.mark_as_read! :all, :for => user
         end
       end
+      
+      include ReaderInstanceMethods
     end
     
     def acts_as_readable(options={})
@@ -41,18 +43,27 @@ module Unread
                                                   AND read_marks.user_id        = #{user.id}
                                                   AND read_marks.timestamp     >= #{self.table_name}.#{readable_options[:on]}",
                    :conditions => 'read_marks.id IS NULL' }
-        if last = read_timestamp(user)
-          result[:conditions] += " AND #{self.table_name}.#{readable_options[:on]} > '#{last.to_s(:db)}'"
+        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
+          result[:conditions] += " AND #{self.table_name}.#{readable_options[:on]} > '#{global_time_stamp.to_s(:db)}'"
         end
         result
       }
       
-      extend ClassMethods
-      include InstanceMethods
+      send scope_method, :with_read_marks_for, lambda { |user| 
+        assert_reader(user)
+      
+        { :select => "#{self.table_name}.*, read_marks.id AS read_mark_id",
+          :joins => "LEFT JOIN read_marks ON read_marks.readable_type  = '#{self.base_class.name}'
+                                         AND read_marks.readable_id    = #{self.table_name}.id
+                                         AND read_marks.user_id        = #{user.id}
+                                         AND read_marks.timestamp     >= #{self.table_name}.#{readable_options[:on]}" }
+      }
+      extend ReadableClassMethods
+      include ReadableInstanceMethods
     end
   end
   
-  module ClassMethods
+  module ReadableClassMethods
     def mark_as_read!(target, options)
       raise ArgumentError unless target == :all || target.is_a?(Array)
       
@@ -63,8 +74,6 @@ module Unread
         reset_read_marks!(user)
       elsif target.is_a?(Array)  
         ReadMark.transaction do
-          last = read_timestamp(user)
-      
           target.each do |obj|
             raise ArgumentError unless obj.is_a?(self)
         
@@ -77,17 +86,8 @@ module Unread
       end
     end
     
-    def read_mark(user)
-      assert_reader(user)
-      user.read_marks.readable_type(self.base_class.name).global.first
-    end
-    
-    def read_timestamp(user)
-      read_mark(user).try(:timestamp)
-    end
-
     def set_read_mark(user, timestamp)
-      rm = read_mark(user) || user.read_marks.build(:readable_type => self.base_class.name)
+      rm = user.read_mark_global(self) || user.read_marks.build(:readable_type => self.base_class.name)
       rm.timestamp = timestamp
       rm.save!
     end    
@@ -156,9 +156,20 @@ module Unread
     end
   end
   
-  module InstanceMethods 
+  module ReadableInstanceMethods 
     def unread?(user)
-      self.class.unread_by(user).exists?(self)
+      if self.respond_to?(:read_mark_id)
+        # For use with scope "with_read_marks_for"
+        return false if self.read_mark_id
+        
+        if global_timestamp = user.read_mark_global(self.class).try(:timestamp)
+          self.send(readable_options[:on]) > global_timestamp
+        else
+          true
+        end
+      else
+        self.class.unread_by(user).exists?(self)
+      end
     end
     
     def mark_as_read!(options)
@@ -167,7 +178,7 @@ module Unread
       
       ReadMark.transaction do
         if unread?(user)
-          rm = read_mark(user) || read_marks.build(:user => user)
+          rm = read_mark(user) || read_marks.build(:user_id => user.id)
           rm.timestamp = self.send(readable_options[:on])
           rm.save!
         end
@@ -178,6 +189,16 @@ module Unread
       read_marks.user(user).first
     end
   end
+  
+  module ReaderInstanceMethods
+    def read_mark_global(klass)
+      instance_var_name = "@read_mark_global_#{klass.name}"
+      instance_variable_get(instance_var_name) || begin # memoize
+        obj = self.read_marks.readable_type(klass.base_class.name).global.first
+        instance_variable_set(instance_var_name, obj)
+      end
+    end
+  end
 end
 
 ActiveRecord::Base.send :include, Unread

data/lib/unread/version.rb

@@ -1,3 +1,3 @@
 module Unread
-  VERSION = '0.0.7'
+  VERSION = '0.1.0'
 end

data/test/unread_test.rb

@@ -40,6 +40,18 @@ class UnreadTest < ActiveSupport::TestCase
     }
   end
   
+  def test_with_read_marks_for
+    @email1.mark_as_read! :for => @reader
+    
+    emails = Email.with_read_marks_for(@reader).all
+
+    assert emails[0].read_mark_id.present?
+    assert emails[1].read_mark_id.nil?
+    
+    assert_equal false, emails[0].unread?(@reader)
+    assert_equal true, emails[1].unread?(@reader)
+  end
+  
   def test_scope_after_reset
     @email1.mark_as_read! :for => @reader
     
@@ -105,7 +117,7 @@ class UnreadTest < ActiveSupport::TestCase
   
   def test_mark_all_as_read
     Email.mark_as_read! :all, :for => @reader
-    assert_equal Time.now.to_s, Email.read_mark(@reader).timestamp.to_s
+    assert_equal Time.now.to_s, @reader.read_mark_global(Email).try(:timestamp).to_s
     
     assert_equal [], @reader.read_marks.single
     assert_equal 0, ReadMark.single.count

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: unread
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 7
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors: 
 - Georg Ledermann
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-29 00:00:00 Z
+date: 2012-04-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: unread
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Manages read/unread status of ActiveRecord objects