acts_as_readable 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28febc32aaf17802d8db7b624fc3dce68bf6620d438b8a2bab8c7aa2cc8620ca
-  data.tar.gz: 6ad32b0cf210c6806c90611e6cc2575a5d710b87e65bd8d0d08ef35bde28627b
+  metadata.gz: 26f1b10303846fe0f6adb4dd943ca37ba592463bfaf57b6dbf8f55008bca9d9f
+  data.tar.gz: c108f52d20a6b6e32f76b57486a87dffcea367b33e2b9d11845761cbde28bb76
 SHA512:
-  metadata.gz: 42f65a6d0f3071710fa9cbdb4b65c507f0a753dc299294989d5c908148512e3443514f4f500555be7fa01fcf3ccb618435a9a8a5197398668f3319d8d0b0daaf
-  data.tar.gz: cbd81ccf4ea4d53f58ea46c67cf5d625daa83909476d84597eb4caf6c0ceae4f826579543240cee80bad5d231de4038072a3f59f5809d7c219117355418556a6
+  metadata.gz: 2cdf040047e4f4985c51d2bd1a0b3f207f4f8d6ee7c17f3732c5c93a09f89c2a842ec670e970ff5c8cb0f00dc0bf02fdbff9fe04b3d154b3881f4d52db17f209
+  data.tar.gz: 335b0e36faf70e2385bc806a5900a4eddaf66ab0e8fdf18b9c2850a041329408c89b0c8d6107eb29a596bcee7c3217522fc5a2907d625b202fec5ce61d19f0f7

data/README.rdoc

@@ -32,6 +32,13 @@ TODO...
 
 	bob.readings                      # => [<Reading 1>]
 
+=== Upgrading from 2.3.x to 2.4.0
+
+Version 2.4.0 now supports reading and querying against STI subclasses, even when the read and queried subclass don't
+match. This requires you to migrate the `readings.readable_type` column data to the base class name of the stored class
+name, as in versions prior to 2.4.0 the column stored the class name of whatever instance was being read, event STI
+subclasses.
+
 === Testing
 
 There are multiple gemfiles available for testing against different Rails versions.  Set `BUNDLE_GEMFILE` to target them, e.g.
@@ -40,4 +47,4 @@ There are multiple gemfiles available for testing against different Rails versio
   BUNDLE_GEMFILE=gemfiles/rails7.gemfile bundle exec rspec
 
 
-Copyright (c) 2012 Culture Code Software Consulting. Released under the MIT license
+Copyright (c) 2024 Culture Code Software Consulting. Released under the MIT license

data/lib/acts_as_readable/acts_as_readable.rb

@@ -6,8 +6,6 @@ module ActsAsReadable
       class_attribute :acts_as_readable_options
       self.acts_as_readable_options = options
 
-      User.has_many :readings,  :dependent => :delete_all
-
       has_many :readings, :as => :readable, :dependent => :delete_all
       has_many :readers, lambda { where :readings => {:state => 'read'} }, :through => :readings, :source => :user
 
@@ -46,7 +44,11 @@ module ActsAsReadable
     end
 
     def self.outer_join_readings(scope, user)
-      scope.joins("LEFT OUTER JOIN readings ON readings.readable_type = '#{scope.model.name}' AND readings.readable_id = #{scope.model.table_name}.id AND readings.user_id = #{user.id}")
+      scope.joins("LEFT OUTER JOIN readings ON readings.readable_type = '#{readable_type(scope.model)}' AND readings.readable_id = #{scope.model.table_name}.id AND readings.user_id = #{user.id}")
+    end
+
+    def self.readable_type(readable_class)
+      readable_class.base_class.name
     end
   end
 
@@ -54,7 +56,7 @@ module ActsAsReadable
     # Find all the readings of the readables by the user in a single SQL query and cache them in the readables for use in the view.
     def cache_readings_for(readables, user)
       readings = []
-      Reading.where(:readable_type => name, :readable_id => readables.collect(&:id), :user_id => user.id).each do |reading|
+      Reading.where(:readable_type => HelperMethods.readable_type(self), :readable_id => readables.collect(&:id), :user_id => user.id).each do |reading|
         readings[reading.readable_id] = reading
       end
 
@@ -69,7 +71,7 @@ module ActsAsReadable
     # If a :cache option has been set in acts_as_readable, a timestamp will be updated on the user instead of creating individual readings for each record
     def read_by!(user)
       if user.has_attribute?(acts_as_readable_options[:cache])
-        Reading.where(:user_id => user.id, :readable_type => name).delete_all
+        Reading.where(:user_id => user.id, :readable_type => HelperMethods.readable_type(self)).delete_all
         user.update_column(acts_as_readable_options[:cache], Time.now)
       else
         unread_by(user).find_each do |record|
@@ -88,7 +90,7 @@ module ActsAsReadable
 
     def read_by!(user)
       # Find an existing reading and update the record so we can know when the thing was first read, and the last time we read it
-      reading = Reading.find_or_initialize_by(:user_id => user.id, :readable_id => self.id, :readable_type => self.class.name)
+      reading = Reading.find_or_initialize_by(:user_id => user.id, :readable_id => self.id, :readable_type => HelperMethods.readable_type(self.class))
       reading.updated_at = Time.now # Explicitly set the read time to now in order to force a save in case we haven't changed anything else about the reading
       reading.state = :read
       reading.save!
@@ -98,7 +100,7 @@ module ActsAsReadable
     end
 
     def unread_by!(user)
-      reading = Reading.find_or_initialize_by(:user_id => user.id, :readable_id => self.id, :readable_type => self.class.name)
+      reading = Reading.find_or_initialize_by(:user_id => user.id, :readable_id => self.id, :readable_type => HelperMethods.readable_type(self.class))
       reading.state = :unread
       reading.save!
     end

data/spec/acts_as_readable_spec.rb

@@ -2,235 +2,250 @@
 require 'spec_helper'
 
 describe 'acts_as_readable' do
-  before(:each) do
-    @comment = Comment.create
-    @user = User.create
-  end
-
-  describe "the unread scope" do
-    it "should not return records explicitly marked as read" do
-      @comment.read_by! @user
-      expect( Comment.unread_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records without readings if the user hasn't 'read all'" do
-      expect( Comment.unread_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user hasn't 'read all'" do
-      @comment.unread_by! @user
-      expect( Comment.unread_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user has 'read all' before the record was marked unread" do
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( Comment.unread_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread after the user 'read all'" do
-      @comment.read_by! @user
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( Comment.unread_by(@user) ).to include(@comment)
-    end
-
-    it "should not return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( Comment.unread_by(@user) ).not_to include(@comment)
-    end
-
-    it "should not return records that have been updated since they were last read" do
-      @comment.read_by! @user
-      @comment.touch
-      expect( Comment.unread_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records that have been updated since they were last unread" do
-      @comment.unread_by! @user
-      @comment.touch
-      expect( Comment.unread_by(@user) ).to include(@comment)
+  shared_examples_for 'a readable class' do |readable_class, queryable_class|
+    before(:each) do
+      @readable = readable_class.create
+      @queryable = @readable.becomes!(queryable_class)
+      @user = User.create
+    end
+
+    describe "the unread scope" do
+      it "should not return records explicitly marked as read" do
+        @readable.read_by! @user
+        expect(queryable_class.unread_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records without readings if the user hasn't 'read all'" do
+        expect(queryable_class.unread_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user hasn't 'read all'" do
+        @readable.unread_by! @user
+        expect(queryable_class.unread_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user has 'read all' before the record was marked unread" do
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(queryable_class.unread_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread after the user 'read all'" do
+        @readable.read_by! @user
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(queryable_class.unread_by(@user)).to include(@queryable)
+      end
+
+      it "should not return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(queryable_class.unread_by(@user)).not_to include(@queryable)
+      end
+
+      it "should not return records that have been updated since they were last read" do
+        @readable.read_by! @user
+        @readable.touch
+        expect(queryable_class.unread_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records that have been updated since they were last unread" do
+        @readable.unread_by! @user
+        @readable.touch
+        expect(queryable_class.unread_by(@user)).to include(@queryable)
+      end
+    end
+
+    describe "the read scope" do
+      it "should not return records without readings if the user has not 'read all'" do
+        expect(queryable_class.read_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records without readings if the user has 'read all' since the last time the record was updated" do
+        readable_class.read_by! @user
+        expect(queryable_class.read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as read if the user hasn't 'read all'" do
+        @readable.read_by! @user
+        expect(queryable_class.read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as read if the user has 'read all' before the record was marked read" do
+        readable_class.read_by! @user
+        @readable.read_by! @user
+        expect(queryable_class.read_by(@user)).to include(@queryable)
+      end
+
+      it "should not return records explicitly marked as unread after the user 'read all'" do
+        @readable.read_by! @user
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(queryable_class.read_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(queryable_class.read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records that have been updated since they were last read" do
+        @readable.read_by! @user
+        @readable.touch
+        expect(queryable_class.read_by(@user)).to include(@queryable)
+      end
+    end
+
+    describe "the latest_update_read_by scope" do
+      it "should return records without readings if the user has 'read all' since the last time the record was updated" do
+        readable_class.read_by! @user
+        expect(queryable_class.latest_update_read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as read if the user hasn't 'read all'" do
+        @readable.read_by! @user
+        expect(queryable_class.latest_update_read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as read if the user has 'read all' before the record was marked unread" do
+        readable_class.read_by! @user
+        @readable.read_by! @user
+        expect(queryable_class.latest_update_read_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(queryable_class.latest_update_read_by(@user)).to include(@queryable)
+      end
+
+      it "should not return records that have been updated since they were last read" do
+        @readable.read_by! @user
+        @readable.touch
+        expect(queryable_class.latest_update_read_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records updated after being read after a bulk read_by" do
+        @readable.read_by! @user
+        @readable.touch
+        readable_class.read_by! @user
+        expect(queryable_class.latest_update_read_by(@user)).to include(@queryable)
+      end
+    end
+
+    describe "the latest_update_unread_by scope" do
+      it "should not return records explicitly marked as read" do
+        @readable.read_by! @user
+        expect(queryable_class.latest_update_unread_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records without readings if the user hasn't 'read all'" do
+        expect(queryable_class.latest_update_unread_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user hasn't 'read all'" do
+        @readable.unread_by! @user
+        expect(queryable_class.latest_update_unread_by(@user)).to include(@queryable)
+      end
+
+      it "should return records explicitly marked as unread if the user has 'read all' before the record was marked unread" do
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(queryable_class.latest_update_unread_by(@user)).to include(@queryable)
+      end
+
+      it "should not return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(queryable_class.latest_update_unread_by(@user)).not_to include(@queryable)
+      end
+
+      it "should return records that have been updated since they were last read" do
+        @readable.read_by! @user
+        @readable.touch
+        expect(queryable_class.latest_update_unread_by(@user)).to include(@queryable)
+      end
+    end
+
+    describe "when checking a specific record for read_by?" do
+      it "should return true if the record hasn't explicitly been read, but the user has 'read all' since the record was created" do
+        readable_class.read_by! @user
+        expect(@queryable.read_by?(@user)).to be_truthy
+      end
+
+      it "should return true if the record hasn't explicitly been read and the user has 'read all' since the record was created but not since it was updated" do
+        readable_class.read_by! @user
+        @readable.touch
+        expect(@queryable.read_by?(@user)).to be_truthy
+      end
+
+      it "should return true if the record has been explicitly marked as read and the user hasn't 'read all'" do
+        @readable.read_by! @user
+        expect(@queryable.read_by?(@user)).to be_truthy
+      end
+
+      it "should return false if the user 'read all' before and then marked the record as unread" do
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(@queryable.read_by?(@user)).to be_falsey
+      end
+
+      it "should return true if the user has explicitly marked it as unread and then 'reads all'" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(@queryable.read_by?(@user)).to be_truthy
+      end
+    end
+
+    describe "when checking a specific record for latest_update_read_by?" do
+      it "should return true if the record hasn't explicitly been read, but the user has 'read all' since the record was updated" do
+        readable_class.read_by! @user
+        expect(@queryable.latest_update_read_by?(@user)).to be_truthy
+      end
+
+      it "should return false if the record hasn't explicitly been read and the user has 'read all' since the record was created but not since it was updated" do
+        readable_class.read_by! @user
+        @readable.touch
+        expect(@queryable.latest_update_read_by?(@user)).to be_falsey
+      end
+
+      it "should return true if the record has been explicitly marked as read and the user hasn't 'read all'" do
+        @readable.read_by! @user
+        expect(@queryable.latest_update_read_by?(@user)).to be_truthy
+      end
+
+      it "should return false if the user 'read all' before and then marked the record as unread" do
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        expect(@queryable.latest_update_read_by?(@user)).to be_falsey
+      end
+
+      it "should return true if the user has explicitly marked it as unread and then 'reads all'" do
+        @readable.unread_by! @user
+        readable_class.read_by! @user
+        expect(@queryable.latest_update_read_by?(@user)).to be_truthy
+      end
+
+      it "should return false if the user 'read all' before and then marked the record as unread using cached readings" do
+        readable_class.read_by! @user
+        @readable.unread_by! @user
+        readable_class.cache_readings_for([@readable], @user)
+        expect(@queryable.latest_update_read_by?(@user)).to be_falsey
+      end
     end
   end
 
-  describe "the read scope" do
-    it "should not return records without readings if the user has not 'read all'" do
-      expect( Comment.read_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records without readings if the user has 'read all' since the last time the record was updated" do
-      Comment.read_by! @user
-      expect( Comment.read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as read if the user hasn't 'read all'" do
-      @comment.read_by! @user
-      expect( Comment.read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as read if the user has 'read all' before the record was marked read" do
-      Comment.read_by! @user
-      @comment.read_by! @user
-      expect( Comment.read_by(@user) ).to include(@comment)
-    end
-
-    it "should not return records explicitly marked as unread after the user 'read all'" do
-      @comment.read_by! @user
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( Comment.read_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( Comment.read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records that have been updated since they were last read" do
-      @comment.read_by! @user
-      @comment.touch
-      expect( Comment.read_by(@user) ).to include(@comment)
-    end
+  context 'the readable is a base class' do
+    it_behaves_like 'a readable class', Comment, Comment
   end
 
-  describe "the latest_update_read_by scope" do
-    it "should return records without readings if the user has 'read all' since the last time the record was updated" do
-      Comment.read_by! @user
-      expect( Comment.latest_update_read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as read if the user hasn't 'read all'" do
-      @comment.read_by! @user
-      expect( Comment.latest_update_read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as read if the user has 'read all' before the record was marked unread" do
-      Comment.read_by! @user
-      @comment.read_by! @user
-      expect( Comment.latest_update_read_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( Comment.latest_update_read_by(@user) ).to include(@comment)
-    end
-
-    it "should not return records that have been updated since they were last read" do
-      @comment.read_by! @user
-      @comment.touch
-      expect( Comment.latest_update_read_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records updated after being read after a bulk read_by" do
-      @comment.read_by! @user
-      @comment.touch
-      Comment.read_by! @user
-      expect( Comment.latest_update_read_by(@user) ).to include(@comment)
-    end
+  context 'when reading an STI record' do
+    it_behaves_like 'a readable class', PrivateComment, PrivateComment
   end
 
-  describe "the latest_update_unread_by scope" do
-    it "should not return records explicitly marked as read" do
-      @comment.read_by! @user
-      expect( Comment.latest_update_unread_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records without readings if the user hasn't 'read all'" do
-      expect( Comment.latest_update_unread_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user hasn't 'read all'" do
-      @comment.unread_by! @user
-      expect( Comment.latest_update_unread_by(@user) ).to include(@comment)
-    end
-
-    it "should return records explicitly marked as unread if the user has 'read all' before the record was marked unread" do
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( Comment.latest_update_unread_by(@user) ).to include(@comment)
-    end
-
-    it "should not return records explicitly marked as unread if the user has 'read all' after the record was marked unread" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( Comment.latest_update_unread_by(@user) ).not_to include(@comment)
-    end
-
-    it "should return records that have been updated since they were last read" do
-      @comment.read_by! @user
-      @comment.touch
-      expect( Comment.latest_update_unread_by(@user) ).to include(@comment)
-    end
-  end
-
-  describe "when checking a specific record for read_by?" do
-    it "should return true if the record hasn't explicitly been read, but the user has 'read all' since the record was created" do
-      Comment.read_by! @user
-      expect( @comment.read_by?(@user) ).to be_truthy
-    end
-
-    it "should return true if the record hasn't explicitly been read and the user has 'read all' since the record was created but not since it was updated" do
-      Comment.read_by! @user
-      @comment.touch
-      expect( @comment.read_by?(@user) ).to be_truthy
-    end
-
-    it "should return true if the record has been explicitly marked as read and the user hasn't 'read all'" do
-      @comment.read_by! @user
-      expect( @comment.read_by?(@user) ).to be_truthy
-    end
-
-    it "should return false if the user 'read all' before and then marked the record as unread" do
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( @comment.read_by?(@user) ).to be_falsey
-    end
-
-    it "should return true if the user has explicitly marked it as unread and then 'reads all'" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( @comment.read_by?(@user) ).to be_truthy
-    end
-  end
-
-  describe "when checking a specific record for latest_update_read_by?" do
-    it "should return true if the record hasn't explicitly been read, but the user has 'read all' since the record was updated" do
-      Comment.read_by! @user
-      expect( @comment.latest_update_read_by?(@user) ).to be_truthy
-    end
-
-    it "should return false if the record hasn't explicitly been read and the user has 'read all' since the record was created but not since it was updated" do
-      Comment.read_by! @user
-      @comment.touch
-      expect( @comment.latest_update_read_by?(@user) ).to be_falsey
-    end
-
-    it "should return true if the record has been explicitly marked as read and the user hasn't 'read all'" do
-      @comment.read_by! @user
-      expect( @comment.latest_update_read_by?(@user) ).to be_truthy
-    end
-
-    it "should return false if the user 'read all' before and then marked the record as unread" do
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      expect( @comment.latest_update_read_by?(@user) ).to be_falsey
-    end
-
-    it "should return true if the user has explicitly marked it as unread and then 'reads all'" do
-      @comment.unread_by! @user
-      Comment.read_by! @user
-      expect( @comment.latest_update_read_by?(@user) ).to be_truthy
-    end
-
-    it "should return false if the user 'read all' before and then marked the record as unread using cached readings" do
-      Comment.read_by! @user
-      @comment.unread_by! @user
-      Comment.cache_readings_for([@comment], @user)
-      expect( @comment.latest_update_read_by?(@user) ).to be_falsey
-    end
+  context 'when reading an STI record and querying against the base class record' do
+    it_behaves_like 'a readable class', PrivateComment, Comment
   end
 end
 `dropdb acts_as_readable_test`

data/spec/spec_helper.rb

@@ -17,6 +17,7 @@ ActiveRecord::Schema.define(:version => 0) do
   end
 
   create_table :comments, :force => true do |t|
+    t.string :type
     t.timestamps
   end
 
@@ -35,6 +36,9 @@ class Comment < ActiveRecord::Base
   acts_as_readable :cache => :comments_read_at
 end
 
+class PrivateComment < Comment
+end
+
 
 def debug_queries
   logger = ActiveRecord::Base.logger

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_readable
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails