unread 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15bcd9b02294f143149629be616cb1299000b90a
+  data.tar.gz: 02641fa74f93b396f2368c0766c51c32b41f0620
+SHA512:
+  metadata.gz: 3784de0accd1416b0fd9d3f1e7948e23636c1aa57c9f4a843b613a5da34ae29c2edba5a8720c3ef10aa3c8c23755f9b7df239305cdbe81e38d4f248a12004b5e
+  data.tar.gz: 11aa961213755d8d9740a3782d2f91192a7d584776ecabea1ded9ccafe30a61d56c5b1eb80452d756684b7bb08818720f19ae7ce36cd4fc13265edf75c7cc9c9

data/.travis.yml

@@ -2,12 +2,13 @@ language: ruby
 rvm:
   - 1.8.7
   - 1.9.3
+  - 2.0.0
 gemfile:
   - ci/Gemfile.rails-3.0.x
   - ci/Gemfile.rails-3.1.x
   - ci/Gemfile.rails-3.2.x
-env:
-  - DB=sqlite
-  - DB=mysql
-before_script:
-  - "mysql -e 'create database myapp_test;' >/dev/null"
+  - ci/Gemfile.rails-4.0.x
+matrix:
+  exclude:
+    - rvm: 1.8.7
+      gemfile: ci/Gemfile.rails-4.0.x

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010,2012 Georg Ledermann
+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

data/README.md

@@ -3,7 +3,7 @@ Unread
 
 Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
-[![Build Status](https://secure.travis-ci.org/ledermann/unread.png)](http://travis-ci.org/ledermann/unread)
+[![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)
 
 ## Features
@@ -18,9 +18,8 @@ Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
 ## Requirements
 
-* Ruby 1.8.7 or 1.9.3
-* Rails 3 (including 3.0, 3.1, 3.2). The use with Rails 2.3 there is a branch named "rails2"
-* Tested with SQLite and MySQL
+* Ruby 1.8.7 or 1.9.3 or 2.0.0
+* Rails 3 (including 3.0, 3.1, 3.2) and Rails 4. For use with Rails 2.3 there is a branch named "rails2"
 * Needs a timestamp field in your models (like created_at or updated_at) with a database index on it
 
 

data/changelog.md

@@ -1,52 +1,58 @@
-0.2.0 - WIP
+# Changelog
+
+## 0.3.0 - 2013/03/17
+
+* Support for Rails 4 (beta1)
+
+## 0.2.0 - 2013/02/18
 
 * Support for Rails 2 dropped
 * Refactoring
 * Added migration generator
 
-0.1.2 - 2013/01/27
+## 0.1.2 - 2013/01/27
 
 * Scopes: Improved parameter check
 
-0.1.1 - 2012/05/01
+## 0.1.1 - 2012/05/01
 
 * Fixed handling namespaced classes. Closes #10 (thanks to @stanislaw)
 
-0.1.0 - 2012/04/21
+## 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
+## 0.0.7 - 2012/02/29
 
 * Cleanup files
 * acts_as_reader: Using inverse_of (available since Rails 2.3.6)
 
-0.0.6 - 2011/11/11
+## 0.0.6 - 2011/11/11
 
 * Fixed #5: Gemspec dependency fix (thanks to @bricker88)
 * Fixed #6: Removed hard coded dependency on a class named "User" (thanks to @mixandgo)
 * Some cleanup
 
-0.0.5 - 2011/09/09
+## 0.0.5 - 2011/09/09
 
 * Fixed class loading issue in development environment
 
-0.0.4 - 2011/08/31
+## 0.0.4 - 2011/08/31
 
 * Ignore multiple calls of acts_as_*
 * Improved error messages
 * Tested with Rails 3.1
 
-0.0.3 - 2011/08/01
+## 0.0.3 - 2011/08/01
 
 * Fixed gemspec by adding development dependencies
 * Testing with Travis CI
 
-0.0.2 - 2011/06/23
+## 0.0.2 - 2011/06/23
 
 * Fixed scoping for ActiveRecord 2.x
 
-0.0.1 - 2011/06/23
+## 0.0.1 - 2011/06/23
 
 * Released as Gem

data/ci/Gemfile.rails-3.0.x

@@ -1,7 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gem 'activerecord', '~> 3.0.10'
 gem 'sqlite3'
-gem 'mysql2', '~> 0.2.11'
 gem 'timecop'
 gem 'rake'

data/ci/Gemfile.rails-3.1.x

@@ -1,7 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gem 'activerecord', '~> 3.1.1'
 gem 'sqlite3'
-gem 'mysql2', '>= 0.3.6'
 gem 'timecop'
 gem 'rake'

data/ci/Gemfile.rails-3.2.x

@@ -1,7 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gem 'activerecord', '~> 3.2.1'
 gem 'sqlite3'
-gem 'mysql2', '>= 0.3.6'
 gem 'timecop'
 gem 'rake'

data/ci/Gemfile.rails-4.0.x

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '4.0.0.beta1'
+gem 'sqlite3'
+gem 'timecop'
+gem 'rake'

data/lib/unread.rb

@@ -1,3 +1,8 @@
+require 'unread/base'
+require 'unread/read_mark'
+require 'unread/readable'
+require 'unread/reader'
+require 'unread/scopes'
 require 'unread/version'
-require 'app/models/read_mark'
-require 'unread/acts_as_readable'
+
+ActiveRecord::Base.send :include, Unread

data/lib/unread/base.rb

@@ -0,0 +1,40 @@
+module Unread
+  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
+
+      options.reverse_merge!(:on => :updated_at)
+      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/{app/models → unread}/read_mark.rb

@@ -1,14 +1,16 @@
 class ReadMark < ActiveRecord::Base
   belongs_to :readable, :polymorphic => true
-  attr_accessible :readable_id, :user_id, :readable_type, :timestamp
+  if ActiveRecord::VERSION::MAJOR < 4
+    attr_accessible :readable_id, :user_id, :readable_type, :timestamp
+  end
 
   validates_presence_of :user_id, :readable_type
 
-  scope :global, where(:readable_id => nil)
-  scope :single, where('readable_id IS NOT NULL')
+  scope :global, lambda { where(:readable_id => nil) }
+  scope :single, lambda { where('readable_id IS NOT NULL') }
   scope :older_than, lambda { |timestamp| where([ 'timestamp < ?', timestamp]) }
 
-  # Returns the class defined by ActsAsReadable::acts_as_reader
+  # 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

data/lib/unread/readable.rb

@@ -0,0 +1,135 @@
+module Unread
+  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)
+        ReadMark.transaction do
+          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
+      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.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
+          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!
+      end
+
+      def reset_read_marks_for_all
+        ReadMark.transaction do
+          ReadMark.delete_all :readable_type => self.base_class.name
+          ReadMark.connection.execute <<-EOT
+            INSERT INTO read_marks (user_id, readable_type, timestamp)
+            SELECT id, '#{self.base_class.name}', '#{Time.now.to_s(:db)}'
+            FROM #{ReadMark.reader_class.table_name}
+          EOT
+        end
+      end
+
+      def reset_read_marks_for_user(user)
+        assert_reader(user)
+
+        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.now
+        end
+      end
+
+      def assert_reader(user)
+        assert_reader_class
+
+        raise ArgumentError, "Class #{user.class.name} is not registered by acts_as_reader!" unless user.is_a?(ReadMark.reader_class)
+        raise ArgumentError, "The given user has no id!" unless user.id
+      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)
+        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) # Rails4 does not return true/false, but nil/count instead.
+        end
+      end
+
+      def mark_as_read!(options)
+        user = options[:for]
+        self.class.assert_reader(user)
+
+        ReadMark.transaction do
+          if unread?(user)
+            rm = read_mark(user) || read_marks.build(:user_id => user.id)
+            rm.timestamp = self.send(readable_options[:on])
+            rm.save!
+          end
+        end
+      end
+
+      def read_mark(user)
+        read_marks.where(:user_id => user.id).first
+      end
+    end
+  end
+end

data/lib/unread/reader.rb

@@ -0,0 +1,13 @@
+module Unread
+  module Reader
+    module InstanceMethods
+      def read_mark_global(klass)
+        instance_var_name = "@read_mark_global_#{klass.name.gsub('::','_')}"
+        instance_variable_get(instance_var_name) || begin # memoize
+          obj = self.read_marks.where(:readable_type => klass.base_class.name).global.first
+          instance_variable_set(instance_var_name, obj)
+        end
+      end
+    end
+  end
+end

data/lib/unread/scopes.rb

@@ -0,0 +1,29 @@
+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    = #{table_name}.id
+                                   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

data/lib/unread/version.rb

@@ -1,3 +1,3 @@
 module Unread
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/test/database.yml

@@ -1,8 +1,3 @@
 sqlite:
   adapter: sqlite3
   database: ":memory:"
-mysql:
-  adapter: mysql2
-  database: myapp_test
-  username:
-  encoding: utf8

data/test/test_helper.rb

@@ -7,8 +7,7 @@ require 'timecop'
 configs = YAML.load_file(File.dirname(__FILE__) + '/database.yml')
 ActiveRecord::Base.configurations = configs
 
-db_name = ENV['DB'] || 'sqlite'
-ActiveRecord::Base.establish_connection(db_name)
+ActiveRecord::Base.establish_connection('sqlite')
 ActiveRecord::Migration.verbose = false
 load(File.dirname(__FILE__) + "/schema.rb")
 

data/test/unread_test.rb

@@ -14,6 +14,7 @@ class UnreadTest < ActiveSupport::TestCase
     Reader.delete_all
     Email.delete_all
     ReadMark.delete_all
+    Timecop.return
   end
 
   def test_schema_has_loaded_correctly
@@ -39,7 +40,7 @@ class UnreadTest < ActiveSupport::TestCase
   def test_with_read_marks_for
     @email1.mark_as_read! :for => @reader
 
-    emails = Email.with_read_marks_for(@reader).all
+    emails = Email.with_read_marks_for(@reader).to_a
 
     assert emails[0].read_mark_id.present?
     assert emails[1].read_mark_id.nil?
@@ -124,8 +125,8 @@ class UnreadTest < ActiveSupport::TestCase
 
   def test_mark_all_as_read
     Email.mark_as_read! :all, :for => @reader
-    assert_equal Time.now.to_s, @reader.read_mark_global(Email).try(:timestamp).to_s
 
+    assert_equal Time.now.utc, @reader.read_mark_global(Email).timestamp.utc
     assert_equal [], @reader.read_marks.single
     assert_equal 0, ReadMark.single.count
     assert_equal 2, ReadMark.global.count
@@ -148,7 +149,7 @@ class UnreadTest < ActiveSupport::TestCase
   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.exists?(other_read_mark.id)
+    assert_equal true, !!ReadMark.exists?(other_read_mark.id) # Rails4 does not return true, but count instead.
   end
 
   def test_reset_read_marks_for_all
@@ -160,6 +161,6 @@ class UnreadTest < ActiveSupport::TestCase
 
 private
   def wait
-    Timecop.travel(1.minute)
+    Timecop.freeze(1.minute.from_now.change(:usec => 0))
   end
 end

data/unread.gemspec

@@ -23,5 +23,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake'
   s.add_development_dependency 'timecop'
   s.add_development_dependency 'sqlite3'
-  s.add_development_dependency 'mysql2'
 end

metadata

@@ -1,97 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: unread
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Georg Ledermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-18 00:00:00.000000000 Z
+date: 2013-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-    none: false
-  type: :runtime
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3'
-    none: false
-- !ruby/object:Gem::Dependency
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
+        version: '3'
+- !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  type: :development
+- !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  type: :development
+- !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-description: ! 'This gem creates a scope for unread objects and adds methods to mark
+description: 'This gem creates a scope for unread objects and adds methods to mark
   objects as read '
 email:
 - mail@georg-ledermann.de
@@ -109,11 +84,15 @@ files:
 - ci/Gemfile.rails-3.0.x
 - ci/Gemfile.rails-3.1.x
 - ci/Gemfile.rails-3.2.x
-- lib/app/models/read_mark.rb
+- ci/Gemfile.rails-4.0.x
 - lib/generators/unread/migration/migration_generator.rb
 - lib/generators/unread/migration/templates/migration.rb
 - lib/unread.rb
-- lib/unread/acts_as_readable.rb
+- lib/unread/base.rb
+- lib/unread/read_mark.rb
+- lib/unread/readable.rb
+- lib/unread/reader.rb
+- lib/unread/scopes.rb
 - lib/unread/version.rb
 - test/database.yml
 - test/schema.rb
@@ -122,27 +101,26 @@ files:
 - unread.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'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: unread
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Manages read/unread status of ActiveRecord objects
 test_files:
 - test/database.yml

data/lib/unread/acts_as_readable.rb

@@ -1,207 +0,0 @@
-module Unread
-  def self.included(base)
-    base.extend ActsAsReadable
-  end
-
-  module ActsAsReadable
-    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 ReaderInstanceMethods
-    end
-
-    def acts_as_readable(options={})
-      class_attribute :readable_options
-
-      options.reverse_merge!(:on => :updated_at)
-      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)
-
-      scope :join_read_marks, lambda { |user|
-        assert_reader(user)
-
-        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]}"
-      }
-
-      scope :unread_by, lambda { |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("#{self.table_name}.#{readable_options[:on]} > '#{global_time_stamp.to_s(:db)}'")
-        end
-
-        result
-      }
-
-      scope :with_read_marks_for, lambda { |user|
-        join_read_marks(user).select("#{self.table_name}.*, read_marks.id AS read_mark_id")
-      }
-
-      extend ReadableClassMethods
-      include ReadableInstanceMethods
-    end
-  end
-
-  module ReadableClassMethods
-    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)
-      ReadMark.transaction do
-        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
-    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.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
-        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!
-    end
-
-    def reset_read_marks_for_all
-      ReadMark.transaction do
-        ReadMark.delete_all :readable_type => self.base_class.name
-        ReadMark.connection.execute <<-EOT
-          INSERT INTO read_marks (user_id, readable_type, timestamp)
-          SELECT id, '#{self.base_class.name}', '#{Time.now.to_s(:db)}'
-          FROM #{ReadMark.reader_class.table_name}
-        EOT
-      end
-    end
-
-    def reset_read_marks_for_user(user)
-      assert_reader(user)
-
-      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.now
-      end
-    end
-
-    def assert_reader(user)
-      assert_reader_class
-
-      raise ArgumentError, "Class #{user.class.name} is not registered by acts_as_reader!" unless user.is_a?(ReadMark.reader_class)
-      raise ArgumentError, "The given user has no id!" unless user.id
-    end
-
-    def assert_reader_class
-      raise RuntimeError, 'There is no class using acts_as_reader!' unless ReadMark.reader_class
-    end
-  end
-
-  module ReadableInstanceMethods
-    def unread?(user)
-      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)
-      user = options[:for]
-      self.class.assert_reader(user)
-
-      ReadMark.transaction do
-        if unread?(user)
-          rm = read_mark(user) || read_marks.build(:user_id => user.id)
-          rm.timestamp = self.send(readable_options[:on])
-          rm.save!
-        end
-      end
-    end
-
-    def read_mark(user)
-      read_marks.where(:user_id => user.id).first
-    end
-  end
-
-  module ReaderInstanceMethods
-    def read_mark_global(klass)
-      instance_var_name = "@read_mark_global_#{klass.name.gsub('::','_')}"
-      instance_variable_get(instance_var_name) || begin # memoize
-        obj = self.read_marks.where(:readable_type => klass.base_class.name).global.first
-        instance_variable_set(instance_var_name, obj)
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.send :include, Unread