acts_as_readable 2.2.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2eb3570785a65d3e80567534270dae5825eceb07fdeec498764c2065f129892
-  data.tar.gz: c9bacbe67acb169365404c423640fd4f25d9536315228d014bea8c6e7e100987
+  metadata.gz: 26f1b10303846fe0f6adb4dd943ca37ba592463bfaf57b6dbf8f55008bca9d9f
+  data.tar.gz: c108f52d20a6b6e32f76b57486a87dffcea367b33e2b9d11845761cbde28bb76
 SHA512:
-  metadata.gz: c7ddc495d6010d7748b134c731908c1a2e71b88b4cc86b8f694729e4bc1c83659e10bf0b0547801012124f1f946d871397ef9ac53c1ff9798a5753bddbf40f5d
-  data.tar.gz: 97cdf31a2684e938da9462d8f6d8f20ca0d6bd7170da449ef7e4eafa7c21633f452bcf6227daacb95541c37747e61aa99bcdb942a3c4e0aaa1f2400c06787d34
+  metadata.gz: 2cdf040047e4f4985c51d2bd1a0b3f207f4f8d6ee7c17f3732c5c93a09f89c2a842ec670e970ff5c8cb0f00dc0bf02fdbff9fe04b3d154b3881f4d52db17f209
+  data.tar.gz: 335b0e36faf70e2385bc806a5900a4eddaf66ab0e8fdf18b9c2850a041329408c89b0c8d6107eb29a596bcee7c3217522fc5a2907d625b202fec5ce61d19f0f7

data/README.rdoc

@@ -32,4 +32,19 @@ TODO...
 
 	bob.readings                      # => [<Reading 1>]
 
-Copyright (c) 2012 Culture Code Software Consulting. Released under the MIT license
+=== 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.
+
+  bundle install
+  BUNDLE_GEMFILE=gemfiles/rails7.gemfile bundle exec rspec
+
+
+Copyright (c) 2024 Culture Code Software Consulting. Released under the MIT license

data/lib/acts_as_readable/acts_as_readable.rb

@@ -6,13 +6,13 @@ 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
 
-      has_many :readings,       :as => :readable, :dependent => :delete_all
-      has_many :readers,        lambda { where :readings => {:state => 'read'} }, :through => :readings, :source => :user
-
-      scope :read_by,           lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.read_conditions(self, user))}
-      scope :unread_by,         lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.unread_conditions(self, user))}
+      scope :read_by, lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.read_conditions(self, user, :created_at))}
+      scope :unread_by, lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.unread_conditions(self, user, :created_at))}
+      scope :latest_update_read_by, lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.read_conditions(self, user, :updated_at))}
+      scope :latest_update_unread_by, lambda {|user| ActsAsReadable::HelperMethods.outer_join_readings(all, user).where(ActsAsReadable::HelperMethods.unread_conditions(self, user, :updated_at))}
 
       extend ActsAsReadable::ClassMethods
       include ActsAsReadable::InstanceMethods
@@ -24,19 +24,19 @@ module ActsAsReadable
   end
 
   module HelperMethods
-    def self.read_conditions(readable_class, user)
-      ["(readable_type IS NULL     AND COALESCE(#{readable_class.table_name}.updated_at < :all_read_at, :true))
-     OR (readable_type IS NOT NULL AND COALESCE(readings.updated_at < :all_read_at, :true))
-     OR (readings.state = 'read')",
-     :all_read_at => all_read_at(readable_class, user), :true => true]
+    def self.read_conditions(readable_class, user, timestamp)
+      ["(readings.state IS NULL    AND COALESCE(#{readable_class.table_name}.#{timestamp} <= :all_read_at, FALSE))
+     OR (readings.state = 'unread' AND COALESCE(readings.updated_at <= :all_read_at, FALSE))
+     OR (readings.state = 'read'   AND #{readable_class.table_name}.#{timestamp} <= readings.#{timestamp})",
+     :all_read_at => all_read_at(readable_class, user)]
     end
 
-    def self.unread_conditions(readable_class, user)
+    def self.unread_conditions(readable_class, user, timestamp)
       # IF there is no reading and it has been updated since we last read all OR there is an unreading and we haven't read all since then
-      ["(readings.state IS NULL    AND COALESCE(#{readable_class.table_name}.updated_at > :all_read_at, :true))
-     OR (readings.state = 'unread' AND COALESCE(readings.updated_at > :all_read_at, :true))
-     OR (readings.state = 'read'   AND COALESCE(#{readable_class.table_name}.updated_at > readings.updated_at, :true))",
-     :all_read_at => all_read_at(readable_class, user), :true => true]
+      ["(readings.state IS NULL    AND COALESCE(#{readable_class.table_name}.#{timestamp} > :all_read_at, TRUE))
+     OR (readings.state = 'unread' AND COALESCE(readings.updated_at > :all_read_at, TRUE))
+     OR (readings.state = 'read'   AND #{readable_class.table_name}.#{timestamp} > readings.#{timestamp})",
+     :all_read_at => all_read_at(readable_class, user)]
     end
 
     def self.all_read_at(readable_class, user)
@@ -44,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
 
@@ -52,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
 
@@ -67,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.delete_all(:user_id => user.id, :readable_type => name)
+        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|
@@ -86,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!
@@ -96,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,140 +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 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 return records that have been updated since they were last read" do
-      @comment.read_by! @user
-      @comment.touch
-      expect( Comment.unread_by(@user) ).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 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 unread" do
-      Comment.read_by! @user
-      @comment.read_by! @user
-      expect( Comment.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.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 "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
+  context 'when reading an STI record' do
+    it_behaves_like 'a readable class', PrivateComment, PrivateComment
   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

@@ -2,7 +2,14 @@ $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'active_record'
 require 'acts_as_readable'
 
-ActiveRecord::Base.establish_connection(:adapter => "postgresql", :database => "acts_as_readable_test") # Not using sqlite3 for testing because of its ridiculous boolean handling
+ActiveRecord::Base.establish_connection(
+  :adapter => "postgresql",
+  :host => "localhost",
+  :encoding => "unicode",
+  :database => "acts_as_readable_test",
+  :username => ENV["POSTGRES_USER"],
+  :password => ENV["POSTGRES_PASSWORD"]
+)
 
 ActiveRecord::Schema.define(:version => 0) do
   create_table :users, :force => true do |t|
@@ -10,6 +17,7 @@ ActiveRecord::Schema.define(:version => 0) do
   end
 
   create_table :comments, :force => true do |t|
+    t.string :type
     t.timestamps
   end
 
@@ -28,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,31 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_readable
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Nicholas Jakobsen
 - Ryan Wallace
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-08 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '8'
   type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
-description:
+        version: '4'
+description: 
 email: contact@culturecode.ca
 executables: []
 extensions: []
@@ -42,7 +76,7 @@ files:
 homepage: http://github.com/culturecode/acts_as_readable
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -57,8 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.3.23
+signing_key: 
 specification_version: 4
 summary: Allows records to be marked as readable. Optimized for bulk, 'mark all as
   read' operations