unread 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d46186ae6d45d389e56f902320bbce46558ac342
-  data.tar.gz: 704c5a93c4967d69dd13c0ce550cccfe5af25679
+  metadata.gz: 9a7a52ce94c2d2bf78f926c90869494d43c7c0d5
+  data.tar.gz: 3f75e1d043b89b5ec6cee60f5b1197106399df23
 SHA512:
-  metadata.gz: 1289afd5a3a6f531ddc2aef5ee8598d58bd0a5b5292deab7a01ed8bd044e64ed79060e53310d682d3f6da88a538e57d2a1b26830e478ddeeb7171da861053c9e
-  data.tar.gz: 055f316a97a375a2c6e266e1cbc34a625562d21c904c0c147b2267caaabe5c8d7d59399b3181e9cc39fc332e411a40f0953e486c8542faed0bf576c947491ecc
+  metadata.gz: 576527e97d9c23f90a6d96061598e890a86c3fcb06a36030472e4e12f04a5abfe231eea980c6a122335319f9630c9c71bb4604e77f01018a7b378046dda736ae
+  data.tar.gz: 34fd6607a8935bf86ca508def361545f0d1a56d6b9c5057102db317dca29769d27a47d98b8059750d6063bb74a6adfee348db47c18453848ed859f4c1e3f2a83

data/README.md

@@ -9,10 +9,10 @@ Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
 ## Features
 
-* Manages unread records for anything you want users to read (like messages, documents, comments etc.)
+* Manages unread records for anything you want readers (e.g. 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 records for a given user
+* Gives you a scope to get the unread records for a given reader
 * Needs only one additional database table
 * Most important: Great performance
 
@@ -51,6 +51,10 @@ rails g unread:migration
 rake db:migrate
 ```
 
+## Upgrade from previous releases
+
+If you upgrade from an older release of this gem, you should read the [upgrade notes](UPGRADE.md).
+
 
 ## Usage
 
@@ -58,9 +62,10 @@ rake db:migrate
 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 }
+  # Optional: Allow a subset of users as readers only
+  def self.reader_scope
+    where(:is_admin => true)
+  end
 end
 
 class Message < ActiveRecord::Base
@@ -173,7 +178,8 @@ SELECT messages.*
 FROM messages
 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.reader_id = 42
+                    AND read_marks.reader_type = 'User'
                     AND read_marks.timestamp >= messages.created_at
 WHERE read_marks.id IS NULL
 AND messages.created_at > '2010-10-20 08:50:00'
@@ -182,4 +188,4 @@ AND messages.created_at > '2010-10-20 08:50:00'
 Hint: You should add a database index on `messages.created_at`.
 
 
-Copyright (c) 2010-2015 [Georg Ledermann](http://www.georg-ledermann.de), released under the MIT license
+Copyright (c) 2010-2015 [Georg Ledermann](http://www.georg-ledermann.de) and [contributors](https://github.com/ledermann/unread/graphs/contributors), released under the MIT license

data/UPGRADE.md

@@ -0,0 +1,49 @@
+# Upgrade notes
+
+## Breaking changes with v0.7.0
+
+There are two important changes needing your attention. Please read the following hints carefully!
+
+
+### Polymorphic readers
+
+The gem accepts any type of classes as reader and it's not limited to `User` class anymore. So you can do stuff like:
+
+```ruby
+Customer.have_not_read(message1)
+message1.mark_as_read! :for => Customer.find(1)
+```
+
+If you are upgrading from v0.6.3 or older, you need to do the following after upgrading:
+
+```shell
+rails g unread:polymorphic_reader_migration
+rake db:migrate
+```
+
+This will alter the `read_marks` table to replace `user` association to a polymorphic association named `reader`. Therefore, `user_id` is going to be renamed to `reader_id` and `reader_type` is going to be added.
+
+This change should not break your code unless you've worked with `ReadMark` model directly.
+
+
+### Defining reader_scope
+
+The class method `acts_as_reader` doesn't take the option `:scope` anymore. If you have used it, please change this ...
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_reader :scope => -> { where(:is_admin => true) }
+end
+```
+
+... to this
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_reader
+
+  def self.reader_scope
+    where(:is_admin => true)
+  end
+end
+```

data/bin/console

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'unread'
+
+$LOAD_PATH.unshift(File.expand_path('..', File.dirname(__FILE__)))
+require 'lib/generators/unread/migration/templates/migration.rb'
+require 'spec/support/spec_migration.rb'
+
+require 'spec/app/models/reader'
+require 'spec/app/models/different_reader'
+require 'spec/app/models/sti_reader'
+require 'spec/app/models/email'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+ActiveRecord::Base.configurations = YAML.load_file('spec/database.yml')
+ActiveRecord::Base.establish_connection(:sqlite)
+ActiveRecord::Migration.verbose = false
+
+UnreadMigration.up
+SpecMigration.up
+
+require 'irb'
+IRB.start

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

@@ -2,11 +2,11 @@ class UnreadMigration < ActiveRecord::Migration
   def self.up
     create_table :read_marks, force: true do |t|
       t.references :readable, polymorphic: { null: false }
-      t.references :user,     null: false
+      t.references :reader,   polymorphic: { null: false }
       t.datetime :timestamp
     end
 
-    add_index :read_marks, [:user_id, :readable_type, :readable_id]
+    add_index :read_marks, [:reader_id, :reader_type, :readable_type, :readable_id], name: 'read_marks_reader_readable_index'
   end
 
   def self.down

data/lib/generators/unread/polymorphic_reader_migration/polymorphic_reader_migration_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Unread
+  class PolymorphicReaderMigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates update migration to make reader of read_markers polymorphic"
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'unread_polymorphic_reader_migration.rb', 'db/migrate/unread_polymorphic_reader_migration.rb'
+    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/polymorphic_reader_migration/templates/unread_polymorphic_reader_migration.rb

@@ -0,0 +1,16 @@
+class UnreadPolymorphicReaderMigration < ActiveRecord::Migration
+  def self.up
+    remove_index :read_marks, [:user_id, :readable_type, :readable_id]
+    rename_column :read_marks, :user_id, :reader_id
+    add_column :read_marks, :reader_type, :string
+    execute "update read_marks set reader_type = 'User'"
+    add_index :read_marks, [:reader_id, :reader_type, :readable_type, :readable_id], name: 'read_marks_reader_readable_index'
+  end
+
+  def self.down
+    remove_index :read_marks, name: 'read_marks_reader_readable_index'
+    remove_column :read_marks, :reader_type
+    rename_column :read_marks, :reader_id, :user_id
+    add_index :read_marks, [:user_id, :readable_type, :readable_id]
+  end
+end

data/lib/unread.rb

@@ -1,9 +1,12 @@
+require 'active_record'
+
 require 'unread/base'
 require 'unread/read_mark'
 require 'unread/readable'
 require 'unread/reader'
 require 'unread/readable_scopes'
 require 'unread/reader_scopes'
+require 'unread/garbage_collector'
 require 'unread/version'
 
-ActiveRecord::Base.send :include, Unread
+ActiveRecord::Base.send :include, Unread

data/lib/unread/base.rb

@@ -4,22 +4,17 @@ module Unread
   end
 
   module Base
-    def acts_as_reader(options={})
-      ReadMark.belongs_to :user, :class_name => self.to_s, inverse_of: :read_marks
-
-      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
+    def acts_as_reader
+      unless ReadMark.reflections.include?(:reader)
+        ReadMark.belongs_to :reader, :polymorphic => true, inverse_of: :read_marks
       end
 
-      ReadMark.reader_class = self
-      ReadMark.reader_options = options
+      has_many :read_marks, :dependent => :delete_all, as: :reader, :inverse_of => :reader
+
+      after_create :setup_new_reader
+
+      ReadMark.reader_classes ||= []
+      ReadMark.reader_classes << self
 
       include Reader::InstanceMethods
       extend Reader::ClassMethods

data/lib/unread/garbage_collector.rb

@@ -0,0 +1,54 @@
+module Unread
+  class GarbageCollector
+    def initialize(readable_class)
+      @readable_class = readable_class
+    end
+    attr_reader :readable_class
+
+    def run!
+      ReadMark.reader_classes.each do |reader_class|
+        readers_to_cleanup(reader_class).each do |reader|
+          if oldest_timestamp = readable_class.read_scope(reader).
+                                  unread_by(reader).
+                                  minimum(readable_class.readable_options[:on])
+            # There are unread items, so update the global read_mark for this reader to the oldest
+            # unread item and delete older read_marks
+            update_read_marks_for_user(reader, oldest_timestamp)
+          else
+            # There is no unread item, so deletes all markers and move global timestamp
+            readable_class.reset_read_marks_for_user(reader)
+          end
+        end
+      end
+    end
+
+  private
+    # Not for every reader a cleanup is needed.
+    # Look for those readers with at least one single read mark
+    def readers_to_cleanup(reader_class)
+      reader_class.
+        reader_scope.
+        joins(:read_marks).
+        where(:read_marks => { :readable_type => readable_class.base_class.name }).
+        group('read_marks.reader_type, read_marks.reader_id').
+        having('COUNT(read_marks.id) > 1')
+    end
+
+    def update_read_marks_for_user(reader, timestamp)
+      ReadMark.transaction do
+        # Delete markers OLDER than the given timestamp
+        reader.read_marks.
+          where(:readable_type => readable_class.base_class.name).
+          single.
+          older_than(timestamp).
+          delete_all
+
+        # Change the global timestamp for this reader
+        rm = reader.read_mark_global(readable_class) || reader.read_marks.build
+        rm.readable_type = readable_class.base_class.name
+        rm.timestamp     = timestamp - 1.second
+        rm.save!
+      end
+    end
+  end
+end

data/lib/unread/read_mark.rb

@@ -1,20 +1,15 @@
 class ReadMark < ActiveRecord::Base
   belongs_to :readable, :polymorphic => true
 
-  validates_presence_of :user_id, :readable_type
+  validates_presence_of :reader_id, :reader_type, :readable_type
 
   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 and options defined by acts_as_reader
-  class_attribute :reader_class
-  class_attribute :reader_options
+  # Returns the classes defined by acts_as_reader
+  class_attribute :reader_classes
 
   # Returns the classes defined by acts_as_readable
   class_attribute :readable_classes
-
-  def self.reader_scope
-    reader_options[:scope].try(:call) || reader_class
-  end
 end

data/lib/unread/readable.rb

@@ -4,21 +4,21 @@ module Unread
       def mark_as_read!(target, options)
         raise ArgumentError unless options.is_a?(Hash)
 
-        user = options[:for]
-        assert_reader(user)
+        reader = options[:for]
+        assert_reader(reader)
 
         if target == :all
-          reset_read_marks_for_user(user)
+          reset_read_marks_for_user(reader)
         elsif target.is_a?(Array)
-          mark_array_as_read(target, user)
+          mark_array_as_read(target, reader)
         else
           raise ArgumentError
         end
       end
 
-      def mark_array_as_read(array, user)
+      def mark_array_as_read(array, reader)
         ReadMark.transaction do
-          global_timestamp = user.read_mark_global(self).try(:timestamp)
+          global_timestamp = reader.read_mark_global(self).try(:timestamp)
 
           array.each do |obj|
             raise ArgumentError unless obj.is_a?(self)
@@ -27,140 +27,103 @@ 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
-              rm.user_id   = user.id
-              rm.timestamp = timestamp
+              rm = obj.read_marks.where(:reader_id => reader.id, :reader_type => reader.class.base_class.name).first || obj.read_marks.build
+              rm.reader_id   = reader.id
+              rm.reader_type = reader.class.base_class.name
+              rm.timestamp   = timestamp
               rm.save!
             end
           end
         end
       end
 
-      # A scope with all items accessable for the given user
+      # A scope with all items accessable for the given reader
       # 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
+      # Should be overriden if a reader doesn't have access to all items
+      # Default: reader has access to all items and should read them all
       #
       # Example:
-      #   def Message.read_scope(user)
-      #     user.visible_messages
+      #   def Message.read_scope(reader)
+      #     reader.visible_messages
       #   end
-      def read_scope(user)
+      def read_scope(reader)
         self
       end
 
       def cleanup_read_marks!
         assert_reader_class
-
-        ReadMark.reader_scope.find_each do |user|
-          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)
-        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 read_marks (user_id, readable_type, timestamp)
-            #{reader_sql}
-          EOT
-        end
+        Unread::GarbageCollector.new(self).run!
       end
 
-      def reset_read_marks_for_user(user)
-        assert_reader(user)
+      def reset_read_marks_for_user(reader)
+        assert_reader(reader)
 
         ReadMark.transaction do
-          ReadMark.delete_all :readable_type => self.base_class.name, :user_id => user.id
+          ReadMark.delete_all :readable_type => self.base_class.name, :reader_id => reader.id, :reader_type => reader.class.base_class.name
 
           ReadMark.create! do |rm|
             rm.readable_type = self.base_class.name
-            rm.user_id       = user.id
+            rm.reader_id     = reader.id
+            rm.reader_type   = reader.class.base_class.name
             rm.timestamp     = Time.current
           end
         end
 
-        user.forget_memoized_read_mark_global
+        reader.forget_memoized_read_mark_global
       end
 
-      def assert_reader(user)
+      def assert_reader(reader)
         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
+        raise ArgumentError, "Class #{reader.class.name} is not registered by acts_as_reader." unless ReadMark.reader_classes.any? { |klass| reader.is_a?(klass) }
+        raise ArgumentError, "The given reader has no id." unless reader.id
       end
 
       def assert_reader_class
-        raise RuntimeError, 'There is no class using acts_as_reader.' unless ReadMark.reader_class
+        raise RuntimeError, 'There is no class using acts_as_reader.' unless ReadMark.reader_classes
       end
     end
 
     module InstanceMethods
-      def unread?(user)
-        if self.respond_to?(:read_mark_id) && read_mark_id_belongs_to?(user)
+      def unread?(reader)
+        if self.respond_to?(:read_mark_id) && read_mark_id_belongs_to?(reader)
           # 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)
+          if global_timestamp = reader.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.id)
+          self.class.unread_by(reader).exists?(self.id)
         end
       end
 
       def mark_as_read!(options)
-        user = options[:for]
-        self.class.assert_reader(user)
+        reader = options[:for]
+        self.class.assert_reader(reader)
 
         ReadMark.transaction do
-          if unread?(user)
-            rm = read_mark(user) || read_marks.build
-            rm.user_id   = user.id
-            rm.timestamp = self.send(readable_options[:on])
+          if unread?(reader)
+            rm = read_mark(reader) || read_marks.build
+            rm.reader_id   = reader.id
+            rm.reader_type = reader.class.base_class.name
+            rm.timestamp   = self.send(readable_options[:on])
             rm.save!
           end
         end
       end
 
-      def read_mark(user)
-        read_marks.where(:user_id => user.id).first
+      def read_mark(reader)
+        read_marks.where(:reader_id => reader.id, reader_type: reader.class.base_class.name).first
       end
 
       private
 
-      def read_mark_id_belongs_to?(user)
-        self.read_mark_user_id == user.id
+      def read_mark_id_belongs_to?(reader)
+        self.read_mark_reader_id == reader.id &&
+          self.read_mark_reader_type == reader.class.base_class.name
       end
     end
   end

data/lib/unread/readable_scopes.rb

@@ -1,20 +1,21 @@
 module Unread
   module Readable
     module Scopes
-      def join_read_marks(user)
-        assert_reader(user)
+      def join_read_marks(reader)
+        assert_reader(reader)
 
         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        = #{quote_bound_value(user.id)}
+               AND read_marks.reader_id      = #{quote_bound_value(reader.id)}
+               AND read_marks.reader_type    = #{quote_bound_value(reader.class.base_class.name)}
                AND read_marks.timestamp     >= #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])}"
       end
 
-      def unread_by(user)
-        result = join_read_marks(user)
+      def unread_by(reader)
+        result = join_read_marks(reader)
 
-        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
+        if global_time_stamp = reader.read_mark_global(self).try(:timestamp)
           result.where("read_marks.id IS NULL
                         AND #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])} > ?", global_time_stamp)
         else
@@ -22,10 +23,10 @@ module Unread
         end
       end
 
-      def read_by(user)
-        result = join_read_marks(user)
+      def read_by(reader)
+        result = join_read_marks(reader)
 
-        if global_time_stamp = user.read_mark_global(self).try(:timestamp)
+        if global_time_stamp = reader.read_mark_global(self).try(:timestamp)
           result.where("read_marks.id IS NOT NULL
                         OR #{quoted_table_name}.#{connection.quote_column_name(readable_options[:on])} <= ?", global_time_stamp)
         else
@@ -33,10 +34,11 @@ module Unread
         end
       end
 
-      def with_read_marks_for(user)
-        join_read_marks(user).select("#{quoted_table_name}.*,
+      def with_read_marks_for(reader)
+        join_read_marks(reader).select("#{quoted_table_name}.*,
                                      read_marks.id AS read_mark_id,
-                                     #{quote_bound_value(user.id)} AS read_mark_user_id")
+                                     #{quote_bound_value(reader.class.base_class.name)} AS read_mark_reader_type,
+                                     #{quote_bound_value(reader.id)} AS read_mark_reader_id")
       end
     end
   end

data/lib/unread/reader.rb

@@ -37,6 +37,15 @@ module Unread
         self.read_mark_readable_type == readable.class.base_class.name &&
         (self.read_mark_readable_id.nil? || self.read_mark_readable_id == readable.id)
       end
+
+      # We assume that a new reader should not be tackled by tons of old messages created BEFORE he signed up.
+      # Instead, the new reader should start with zero unread messages.
+      # If you don't want this, you can override this method in your reader class
+      def setup_new_reader
+        (ReadMark.readable_classes || []).each do |klass|
+          klass.mark_as_read! :all, :for => self
+        end
+      end
     end
   end
-end
+end

data/lib/unread/reader_scopes.rb

@@ -1,13 +1,20 @@
 module Unread
   module Reader
     module Scopes
+      # This class method may be overriden to restrict readers to a subset of records
+      # It must return self or a ActiveRecord::Relation
+      def reader_scope
+        self
+      end
+
       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.reader_id      = #{quoted_table_name}.#{quoted_primary_key}
+               AND read_marks.reader_type    = '#{connection.quote_string base_class.name}'
                AND read_marks.timestamp     >= '#{connection.quoted_date readable.send(readable.class.readable_options[:on])}'"
       end
 

data/lib/unread/version.rb

@@ -1,3 +1,3 @@
 module Unread
-  VERSION = '0.6.3'
+  VERSION = '0.7.0'
 end

data/spec/app/models/different_reader.rb

@@ -0,0 +1,5 @@
+class DifferentReader < ActiveRecord::Base
+  self.primary_key = 'number'
+
+  acts_as_reader
+end

data/spec/{model → app/models}/reader.rb

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

data/spec/app/models/sti_reader.rb

@@ -0,0 +1,6 @@
+class Customer < ActiveRecord::Base
+end
+
+class StiReader < Customer
+  acts_as_reader
+end

data/spec/spec_helper.rb

@@ -9,12 +9,14 @@ SimpleCov.start do
   add_filter '/spec/'
 end
 
-require 'active_record'
 require 'timecop'
 require 'unread'
+require 'generators/unread/migration/templates/migration.rb'
 
-require 'model/reader'
-require 'model/email'
+require 'app/models/reader'
+require 'app/models/different_reader'
+require 'app/models/sti_reader'
+require 'app/models/email'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
@@ -42,7 +44,7 @@ RSpec.configure do |config|
   end
 
   config.after :suite do
-    UnreadMigration.migrate(:down)
+    UnreadMigration.down
   end
 end
 
@@ -62,26 +64,14 @@ def setup_db
   ActiveRecord::Base.default_timezone = :utc
   ActiveRecord::Migration.verbose = false
 
-  require File.expand_path('../../lib/generators/unread/migration/templates/migration.rb', __FILE__)
-  UnreadMigration.migrate(:up)
-
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :readers, :primary_key => 'number', :force => true do |t|
-      t.string :name
-    end
-
-    create_table :documents, :primary_key => 'uid', :force => true do |t|
-      t.string :type
-      t.string :subject
-      t.text :content
-      t.datetime :created_at
-      t.datetime :updated_at
-    end
-  end
+  UnreadMigration.up
+  SpecMigration.up
 end
 
 def clear_db
   Reader.delete_all
+  DifferentReader.delete_all
+  StiReader.delete_all
   Email.delete_all
   ReadMark.delete_all
 end

data/spec/support/spec_migration.rb

@@ -0,0 +1,23 @@
+class SpecMigration < ActiveRecord::Migration
+  def self.up
+    create_table :readers, :primary_key => 'number', :force => true do |t|
+      t.string :name
+    end
+
+    create_table :different_readers, :primary_key => 'number', :force => true do |t|
+      t.string :name
+    end
+
+    create_table :customers, :force => true do |t|
+      t.string :type
+    end
+
+    create_table :documents, :primary_key => 'uid', :force => true do |t|
+      t.string :type
+      t.string :subject
+      t.text :content
+      t.datetime :created_at
+      t.datetime :updated_at
+    end
+  end
+end

data/spec/{base_spec.rb → unread/base_spec.rb}

@@ -14,7 +14,7 @@ describe Unread::Base do
     end
 
     it "should define association for ReadMark" do
-      expect(@reader.read_marks.first.user).to eq(@reader)
+      expect(@reader.read_marks.first.reader).to eq(@reader)
     end
 
     it "should reset read_marks for created reader" do

data/spec/unread/garbage_collector_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Unread::GarbageCollector do
+  before :each do
+    @reader = Reader.create! :name => 'David'
+    @other_reader = Reader.create :name => 'Matz'
+    @sti_reader = StiReader.create!
+    wait
+    @email1 = Email.create!
+    wait
+    @email2 = Email.create!
+  end
+
+  describe :run! do
+    it "should delete all single read marks" do
+      expect(@reader.read_marks.single.count).to eq 0
+
+      @email1.mark_as_read! :for => @reader
+
+      expect(Email.unread_by(@reader)).to eq [@email2]
+      expect(@reader.read_marks.single.count).to eq 1
+
+      Unread::GarbageCollector.new(Email).run!
+
+      @reader.reload
+      expect(@reader.read_marks.single.count).to eq 0
+    end
+
+    it "should reset if all objects are read" do
+      @email1.mark_as_read! :for => @reader
+      @email2.mark_as_read! :for => @reader
+
+      expect(@reader.read_marks.single.count).to eq 2
+
+      Unread::GarbageCollector.new(Email).run!
+
+      expect(@reader.read_marks.single.count).to eq 0
+    end
+
+    it "should not delete read marks from other readables" do
+      other_read_mark = @reader.read_marks.create! do |rm|
+        rm.readable_type = 'Foo'
+        rm.readable_id   = 42
+        rm.timestamp     = 5.years.ago
+      end
+
+      Unread::GarbageCollector.new(Email).run!
+
+      expect(ReadMark.exists?(other_read_mark.id)).to be_truthy
+    end
+  end
+end

data/spec/{read_mark_spec.rb → unread/read_mark_spec.rb}

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe ReadMark do
   it "should have reader_class" do
-    expect(ReadMark.reader_class).to eq Reader
-  end
-
-  it "should have reader_scope" do
-    expect(ReadMark.reader_scope).to eq Reader.not_foo.not_bar
+    expect(ReadMark.reader_classes).to eq [Reader, DifferentReader, StiReader]
   end
 
   it "should have readable_classes" do

data/spec/{readable_spec.rb → unread/readable_spec.rb}

@@ -4,6 +4,7 @@ describe Unread::Readable do
   before :each do
     @reader = Reader.create! :name => 'David'
     @other_reader = Reader.create :name => 'Matz'
+    @sti_reader = StiReader.create!
     wait
     @email1 = Email.create!
     wait
@@ -279,7 +280,7 @@ describe Unread::Readable do
       expect(@reader.read_mark_global(Email).timestamp).to eq Time.current
       expect(@reader.read_marks.single).to eq []
       expect(ReadMark.single.count).to eq 0
-      expect(ReadMark.global.count).to eq 2
+      expect(ReadMark.global.count).to eq 3
     end
 
     it "should mark all objects as read with existing read objects" do
@@ -309,51 +310,10 @@ describe Unread::Readable do
     end
   end
 
-  describe :reset_read_marks_for_all do
-    it "should reset read marks" do
-      Email.reset_read_marks_for_all
-
-      expect(ReadMark.single.count).to eq 0
-      expect(ReadMark.global.count).to eq 2
-    end
-  end
-
   describe :cleanup_read_marks! do
-    it "should delete all single read marks" do
-      expect(@reader.read_marks.single.count).to eq 0
-
-      @email1.mark_as_read! :for => @reader
-
-      expect(Email.unread_by(@reader)).to eq [@email2]
-      expect(@reader.read_marks.single.count).to eq 1
-
+    it "should run garbage collector" do
+      expect(Unread::GarbageCollector).to receive(:new).with(Email).and_return(double :run! => true)
       Email.cleanup_read_marks!
-
-      @reader.reload
-      expect(@reader.read_marks.single.count).to eq 0
-    end
-
-    it "should reset if all objects are read" do
-      @email1.mark_as_read! :for => @reader
-      @email2.mark_as_read! :for => @reader
-
-      expect(@reader.read_marks.single.count).to eq 2
-
-      Email.cleanup_read_marks!
-
-      expect(@reader.read_marks.single.count).to eq 0
-    end
-
-    it "should not delete read marks from other readables" do
-      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
     end
   end
 end

data/spec/unread/reader_scopes_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Unread::Reader::Scopes do
+  it 'should define reader_scope' do
+    expect(Reader.reader_scope).to eq Reader.not_foo.not_bar
+    expect(DifferentReader.reader_scope).to eq DifferentReader
+    expect(StiReader.reader_scope).to eq StiReader
+  end
+end

data/spec/{reader_spec.rb → unread/reader_spec.rb}

@@ -4,6 +4,7 @@ describe Unread::Reader do
   before :each do
     @reader = Reader.create! :name => 'David'
     @other_reader = Reader.create :name => 'Matz'
+    @different_reader = DifferentReader.create! :name => 'Behrooz', :number => @reader.number
     wait
     @email1 = Email.create!
     wait
@@ -25,6 +26,25 @@ describe Unread::Reader do
       expect(Reader.have_not_read(@email2)).to eq [@reader, @other_reader]
     end
 
+    it "should take the type of reader into account" do
+      # even though the id of @reader and @different_reader is the same because
+      # they are different object types, the @email1 should only be marked as
+      # read for @reader.
+      @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(DifferentReader.have_not_read(@email1)).to eq [@different_reader]
+      expect(DifferentReader.have_not_read(@email1).count).to eq 1
+
+      @email1.mark_as_read! :for => @different_reader
+
+      expect(DifferentReader.have_not_read(@email1).count).to eq 0
+
+      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 {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unread
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Georg Ledermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-27 00:00:00.000000000 Z
+date: 2015-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -126,7 +126,8 @@ description: 'This gem creates a scope for unread objects and adds methods to ma
   objects as read '
 email:
 - mail@georg-ledermann.de
-executables: []
+executables:
+- console
 extensions: []
 extra_rdoc_files: []
 files:
@@ -136,6 +137,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- UPGRADE.md
+- bin/console
 - ci/Gemfile-rails-3-0
 - ci/Gemfile-rails-3-1
 - ci/Gemfile-rails-3-2
@@ -144,25 +147,33 @@ files:
 - ci/Gemfile-rails-4-2
 - lib/generators/unread/migration/migration_generator.rb
 - lib/generators/unread/migration/templates/migration.rb
+- lib/generators/unread/polymorphic_reader_migration/polymorphic_reader_migration_generator.rb
+- lib/generators/unread/polymorphic_reader_migration/templates/unread_polymorphic_reader_migration.rb
 - lib/unread.rb
 - lib/unread/base.rb
+- lib/unread/garbage_collector.rb
 - lib/unread/read_mark.rb
 - lib/unread/readable.rb
 - lib/unread/readable_scopes.rb
 - lib/unread/reader.rb
 - lib/unread/reader_scopes.rb
 - lib/unread/version.rb
-- spec/base_spec.rb
+- spec/app/models/different_reader.rb
+- spec/app/models/email.rb
+- spec/app/models/reader.rb
+- spec/app/models/sti_reader.rb
 - spec/database.yml
-- 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
+- spec/support/spec_migration.rb
 - spec/support/timecop.rb
+- spec/unread/base_spec.rb
+- spec/unread/garbage_collector_spec.rb
+- spec/unread/read_mark_spec.rb
+- spec/unread/readable_spec.rb
+- spec/unread/reader_scopes_spec.rb
+- spec/unread/reader_spec.rb
 - unread.gemspec
 homepage: https://github.com/ledermann/unread
 licenses:
@@ -184,19 +195,24 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: unread
-rubygems_version: 2.4.8
+rubygems_version: 2.5.0
 signing_key: 
 specification_version: 4
 summary: Manages read/unread status of ActiveRecord objects
 test_files:
-- spec/base_spec.rb
+- spec/app/models/different_reader.rb
+- spec/app/models/email.rb
+- spec/app/models/reader.rb
+- spec/app/models/sti_reader.rb
 - spec/database.yml
-- 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
+- spec/support/spec_migration.rb
 - spec/support/timecop.rb
+- spec/unread/base_spec.rb
+- spec/unread/garbage_collector_spec.rb
+- spec/unread/read_mark_spec.rb
+- spec/unread/readable_spec.rb
+- spec/unread/reader_scopes_spec.rb
+- spec/unread/reader_spec.rb