followable_behaviour 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f52a9f214e6fd3520f27e04bbef950e6d95ed728fbfe2b674045e4aebf618a67
+  data.tar.gz: 551eb48d28477189097281fe59a8e20c33168e567d04c4b57ce1e4eb9eb702b3
+SHA512:
+  metadata.gz: e52c0f2d30a8b478b033241ce44d622d8654665c62e69dde6d0ff6db06a4617bbd8e285eba050a0e4b2d045391d4636336cf3d9a8f56b99d99bdd491ffa93641
+  data.tar.gz: 40b075359dbedd9665762d6d141d43c5c6eb086b9f789d900d634f65dddc2f9ab6cd2594e2faf9512262193a9425791d5be71a09a6f61e3192f4933e8bfacac5

data/CHANGELOG

@@ -0,0 +1 @@
+

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in followable_behaviour.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,171 @@
+PATH
+  remote: .
+  specs:
+    followable_behaviour (0.1.0)
+      activerecord (~> 7.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.4)
+      actionpack (= 7.0.4)
+      activesupport (= 7.0.4)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.4)
+      actionpack (= 7.0.4)
+      activejob (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.4)
+      actionpack (= 7.0.4)
+      actionview (= 7.0.4)
+      activejob (= 7.0.4)
+      activesupport (= 7.0.4)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.4)
+      actionview (= 7.0.4)
+      activesupport (= 7.0.4)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.4)
+      actionpack (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.4)
+      activesupport (= 7.0.4)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.4)
+      activesupport (= 7.0.4)
+      globalid (>= 0.3.6)
+    activemodel (7.0.4)
+      activesupport (= 7.0.4)
+    activerecord (7.0.4)
+      activemodel (= 7.0.4)
+      activesupport (= 7.0.4)
+    activestorage (7.0.4)
+      actionpack (= 7.0.4)
+      activejob (= 7.0.4)
+      activerecord (= 7.0.4)
+      activesupport (= 7.0.4)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    builder (3.2.4)
+    concurrent-ruby (1.1.10)
+    crass (1.0.6)
+    date (3.3.3)
+    erubi (1.12.0)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.19.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.8.0.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.17.0)
+    net-imap (0.3.4)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.1)
+      timeout
+    net-smtp (0.3.3)
+      net-protocol
+    nio4r (2.5.8)
+    nokogiri (1.14.0-x86_64-darwin)
+      racc (~> 1.4)
+    racc (1.6.2)
+    rack (2.2.5)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rails (7.0.4)
+      actioncable (= 7.0.4)
+      actionmailbox (= 7.0.4)
+      actionmailer (= 7.0.4)
+      actionpack (= 7.0.4)
+      actiontext (= 7.0.4)
+      actionview (= 7.0.4)
+      activejob (= 7.0.4)
+      activemodel (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      bundler (>= 1.15.0)
+      railties (= 7.0.4)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.4)
+      loofah (~> 2.19, >= 2.19.1)
+    railties (7.0.4)
+      actionpack (= 7.0.4)
+      activesupport (= 7.0.4)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rake (13.0.6)
+    shoulda (4.0.0)
+      shoulda-context (~> 2.0)
+      shoulda-matchers (~> 4.0)
+    shoulda-context (2.0.0)
+    shoulda-matchers (4.5.1)
+      activesupport (>= 4.2.0)
+    shoulda_create (0.0.9)
+    sqlite3 (1.6.0-x86_64-darwin)
+    thor (1.2.1)
+    timeout (0.3.1)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.6)
+
+PLATFORMS
+  x86_64-darwin-17
+
+DEPENDENCIES
+  factory_bot (~> 6.2)
+  followable_behaviour!
+  rails (~> 7.0)
+  rake (~> 13.0)
+  shoulda
+  shoulda_create
+  sqlite3 (~> 1.5)
+
+BUNDLED WITH
+   2.3.22

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jean-Baptiste François
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,266 @@
+# FollowableBehaviour
+
+This is a fork from [acts_as_follower](https://github.com/tcocca/acts_as_follower) that has not been updated since 2017.
+
+It's updated against Rails 7 and Ruby 3.1.
+
+followable_behaviour is a gem to allow any model to follow any other model.
+This is accomplished through a double polymorphic relationship on the Follow model.
+There is also built in support for blocking/un-blocking follow records.
+
+Main uses would be for Users to follow other Users or for Users to follow Books, etc...
+
+(Basically, to develop the type of follow system that GitHub has)
+
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add followable_behaviour
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install followable_behaviour
+
+## Usage
+
+### Setup
+
+Make your model(s) that you want to allow to be followed followable_behaviour, just add the mixin:
+```ruby
+  class User < ActiveRecord::Base
+    ...
+    followable_behaviour
+    ...
+  end
+
+  class Book < ActiveRecord::Base
+    ...
+    followable_behaviour
+    ...
+  end
+```
+
+Make your model(s) that can follow other models follower_behaviour
+```ruby
+  class User < ActiveRecord::Base
+    ...
+    follower_behaviour
+    ...
+  end
+```
+
+---
+
+### acts as follower methods
+
+To have an object start following another use the following:
+```ruby
+  book = Book.find(1)
+  user = User.find(1)
+  user.follow(book) # Creates a record for the user as the follower and the book as the followable
+```
+
+To stop following an object use the following
+```ruby
+  user.stop_following(book) # Deletes that record in the Follow table
+```
+
+You can check to see if an object that follower_behaviour is following another object through the following:
+```ruby
+  user.following?(book) # Returns true or false
+```
+
+To get the total number (count) of follows for a user use the following on a model that follower_behaviour
+```ruby
+  user.follow_count # Returns an integer
+```
+
+To get follow records that have not been blocked use the following
+```ruby
+  user.all_follows # returns an array of Follow records
+```
+
+To get all of the records that an object is following that have not been blocked use the following
+```ruby
+  user.all_following
+  # Returns an array of every followed object for the user, this can be a collection of different object types, eg: User, Book
+```
+
+To get all Follow records by a certain type use the following
+```ruby
+  user.follows_by_type('Book') # returns an array of Follow objects where the followable_type is 'Book'
+```
+
+To get all followed objects by a certain type use the following.
+```ruby
+  user.following_by_type('Book') # Returns an array of all followed objects for user where followable_type is 'Book', this can be a collection of different object types, eg: User, Book
+```
+
+There is also a method_missing to accomplish the exact same thing a following_by_type('Book') to make you life easier
+```ruby
+  user.following_users # exact same results as user.following_by_type('User')
+```
+
+To get the count of all Follow records by a certain type use the following
+```ruby
+  user.following_by_type_count('Book') # Returns the sql count of the number of followed books by that user
+```
+
+There is also a method_missing to get the count by type
+```ruby
+  user.following_books_count # Calls the user.following_by_type_count('Book') method
+```
+
+There is now a method that will just return the Arel scope for follows so that you can chain anything else you want onto it:
+```ruby
+  book.follows_scoped
+```
+
+This does not return the actual follows, just the scope of followings including the followables, essentially:
+```ruby
+  book.follows.unblocked.includes(:followable)
+```
+
+The following methods take an optional hash parameter of ActiveRecord options (:limit, :order, etc...)
+```ruby
+  follows_by_type, all_follows, all_following, following_by_type
+```
+
+---
+
+### acts as followable methods
+
+To get all the followers of a model that followable_behaviour
+```ruby
+  book.followers  # Returns an array of all the followers for that book, a collection of different object types (eg. type User or type Book)
+```
+
+There is also a method that will just return the Arel scope for followers so that you can chain anything else you want onto it:
+```ruby
+  book.followers_scoped
+```
+This does not return the actual followers, just the scope of followings including the followers, essentially:
+```ruby
+  book.followings.includes(:follower)
+```
+
+To get just the number of follows use
+```ruby
+  book.followers_count
+```
+
+To get the followers of a certain type, eg: all followers of type 'User'
+```ruby
+  book.followers_by_type('User') # Returns an array of the user followers
+```
+
+There is also a method_missing for this to make it easier:
+```ruby
+  book.user_followers # Calls followers_by_type('User')
+```
+
+To get just the sql count of the number of followers of a certain type use the following
+```ruby
+  book.followers_by_type_count('User') # Return the count on the number of followers of type 'User'
+```
+
+Again, there is a method_missing for this method as well
+```ruby
+  book.count_user_followers # Calls followers_by_type_count('User')
+```
+
+To see is a model that followable_behaviour is followed by a model that follower_behaviour use the following
+```ruby
+  book.followed_by?(user)
+  # Returns true if the current instance is followed by the passed record
+  # Returns false if the current instance is blocked by the passed record or no follow is found
+```
+
+To block a follower call the following
+```ruby
+  book.block(user)
+  # Blocks the user from appearing in the followers list, and blocks the book from appearing in the user.all_follows or user.all_following lists
+```
+
+To unblock is just as simple
+```ruby
+  book.unblock(user)
+```
+
+To get all blocked records
+```ruby
+  book.blocks # Returns an array of blocked follower records (only unblocked) (eg. type User or type Book)
+```
+
+If you only need the number of blocks use the count method provided
+```ruby
+  book.blocked_followers_count
+```
+
+Unblocking deletes all records of that follow, instead of just the :blocked attribute => false the follow is deleted.  So, a user would need to try and follow the book again.
+I would like to hear thoughts on this, I may change this to make the follow as blocked: false instead of deleting the record.
+
+The following methods take an optional hash parameter of ActiveRecord options (:limit, :order, etc...)
+```ruby
+  followers_by_type, followers, blocks
+```
+
+---
+
+### Follow Model
+
+The Follow model has a set of named_scope's.  In case you want to interface directly with the Follow model you can use them.
+```ruby
+  Follow.unblocked # returns all "unblocked" follow records
+
+  Follow.blocked # returns all "blocked" follow records
+
+  Follow.descending # returns all records in a descending order based on created_at datetime
+```
+
+This method pulls all records created after a certain date.  The default is 2 weeks but it takes an optional parameter.
+```ruby
+  Follow.recent
+  Follow.recent(4.weeks.ago)
+```
+
+Follow.for_follower is a named_scope that is mainly there to reduce code in the modules but it could be used directly.
+It takes an object and will return all Follow records where the follower is the record passed in.
+
+Note that this will return all blocked and unblocked records.
+```ruby
+  Follow.for_follower(user)
+```
+If you don't need the blocked records just use the methods provided for this:
+```ruby
+  user.all_follows
+  # or
+  user.all_following
+```
+
+Follow.for_followable acts the same as its counterpart (for_follower).  It is mainly there to reduce duplication, however it can be used directly.  It takes an object that is the followed object and return all Follow records where that record is the followable. Again, this returns all blocked and unblocked records.
+```ruby
+  Follow.for_followable(book)
+```
+
+Again, if you don't need the blocked records use the method provided for this:
+```ruby
+  book.followers
+```
+If you need blocked records only
+```ruby
+  book.blocks
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://gitlab.com/jbpfran/followable-behaviour.

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: :test
+
+require 'rake'
+require 'rake/testtask'
+
+desc 'Test the followable_behaviour gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/followable_behaviour/follow_scopes.rb

@@ -0,0 +1,45 @@
+module FollowableBehaviour #:nodoc:
+  module FollowScopes
+
+    # returns Follow records where follower is the record passed in.
+    def for_follower(follower)
+      where(follower_id: follower.id, follower_type: parent_class_name(follower))
+    end
+
+    # returns Follow records where followable is the record passed in.
+    def for_followable(followable)
+      where(followable_id: followable.id, followable_type: parent_class_name(followable))
+    end
+
+    # returns Follow records where follower_type is the record passed in.
+    def for_follower_type(follower_type)
+      where(follower_type: follower_type)
+    end
+
+    # returns Follow records where followeable_type is the record passed in.
+    def for_followable_type(followable_type)
+      where(followable_type: followable_type)
+    end
+
+    # returns Follow records from past 2 weeks with default parameter.
+    def recent(from)
+      where(["created_at > ?", (from || 2.weeks.ago).to_s(:db)])
+    end
+
+    # returns Follow records in descending order.
+    def descending
+      order("follows.created_at DESC")
+    end
+
+    # returns unblocked Follow records.
+    def unblocked
+      where(blocked: false)
+    end
+
+    # returns blocked Follow records.
+    def blocked
+      where(blocked: true)
+    end
+
+  end
+end

data/lib/followable_behaviour/followable.rb

@@ -0,0 +1,114 @@
+module FollowableBehaviour #:nodoc:
+  module Followable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def followable_behaviour
+        has_many :followings, as: :followable, dependent: :destroy, class_name: 'Follow'
+        include FollowableBehaviour::Followable::InstanceMethods
+        include FollowableBehaviour::FollowerLib
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns the number of followers a record has.
+      def followers_count
+        self.followings.unblocked.count
+      end
+
+      # Returns the followers by a given type
+      def followers_by_type(follower_type, options={})
+        follows = follower_type.constantize.
+          joins(:follows).
+          where('follows.blocked'         => false,
+                'follows.followable_id'   => self.id,
+                'follows.followable_type' => parent_class_name(self),
+                'follows.follower_type'   => follower_type)
+        if options.has_key?(:limit)
+          follows = follows.limit(options[:limit])
+        end
+        if options.has_key?(:includes)
+          follows = follows.includes(options[:includes])
+        end
+        follows
+      end
+
+      def followers_by_type_count(follower_type)
+        self.followings.unblocked.for_follower_type(follower_type).count
+      end
+
+      # Allows magic names on followers_by_type
+      # e.g. user_followers == followers_by_type('User')
+      # Allows magic names on followers_by_type_count
+      # e.g. count_user_followers == followers_by_type_count('User')
+      def method_missing(m, *args)
+        if m.to_s[/count_(.+)_followers/]
+          followers_by_type_count($1.singularize.classify)
+        elsif m.to_s[/(.+)_followers/]
+          followers_by_type($1.singularize.classify)
+        else
+          super
+        end
+      end
+
+      def respond_to?(m, include_private = false)
+        super || m.to_s[/count_(.+)_followers/] || m.to_s[/(.+)_followers/]
+      end
+
+      def blocked_followers_count
+        self.followings.blocked.count
+      end
+
+      # Returns the followings records scoped
+      def followers_scoped
+        self.followings.includes(:follower)
+      end
+
+      def followers(options={})
+        followers_scope = followers_scoped.unblocked
+        followers_scope = apply_options_to_scope(followers_scope, options)
+        followers_scope.to_a.collect{|f| f.follower}
+      end
+
+      def blocks(options={})
+        blocked_followers_scope = followers_scoped.blocked
+        blocked_followers_scope = apply_options_to_scope(blocked_followers_scope, options)
+        blocked_followers_scope.to_a.collect{|f| f.follower}
+      end
+
+      # Returns true if the current instance is followed by the passed record
+      # Returns false if the current instance is blocked by the passed record or no follow is found
+      def followed_by?(follower)
+        self.followings.unblocked.for_follower(follower).first.present?
+      end
+
+      def block(follower)
+        return if follower == self
+        get_follow_for(follower) ? block_existing_follow(follower) : block_future_follow(follower)
+      end
+
+      def unblock(follower)
+        get_follow_for(follower).try(:delete)
+      end
+
+      def get_follow_for(follower)
+        self.followings.for_follower(follower).first
+      end
+
+      private
+
+      def block_future_follow(follower)
+        Follow.create(followable: self, follower: follower, blocked: true)
+      end
+
+      def block_existing_follow(follower)
+        get_follow_for(follower).block!
+      end
+
+    end
+  end
+end

data/lib/followable_behaviour/follower.rb

@@ -0,0 +1,112 @@
+module FollowableBehaviour #:nodoc:
+  module Follower
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def follower_behaviour
+        has_many :follows, as: :follower, dependent: :destroy
+        include FollowableBehaviour::Follower::InstanceMethods
+        include FollowableBehaviour::FollowerLib
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns true if this instance is following the object passed as an argument.
+      def following?(followable)
+        0 < Follow.unblocked.for_follower(self).for_followable(followable).count
+      end
+
+      # Returns the number of objects this instance is following.
+      def follow_count
+        Follow.unblocked.for_follower(self).count
+      end
+
+      # Creates a new follow record for this instance to follow the passed object.
+      # Does not allow duplicate records to be created.
+      def follow(followable)
+        if self != followable
+          params = {followable_id: followable.id, followable_type: parent_class_name(followable)}
+          self.follows.where(params).first_or_create!
+        end
+      end
+
+      # Deletes the follow record if it exists.
+      def stop_following(followable)
+        if follow = get_follow(followable)
+          follow.destroy
+        end
+      end
+
+      # returns the follows records to the current instance
+      def follows_scoped
+        self.follows.unblocked.includes(:followable)
+      end
+
+      # Returns the follow records related to this instance by type.
+      def follows_by_type(followable_type, options={})
+        follows_scope  = follows_scoped.for_followable_type(followable_type)
+        follows_scope = apply_options_to_scope(follows_scope, options)
+      end
+
+      # Returns the follow records related to this instance with the followable included.
+      def all_follows(options={})
+        follows_scope = follows_scoped
+        follows_scope = apply_options_to_scope(follows_scope, options)
+      end
+
+      # Returns the actual records which this instance is following.
+      def all_following(options={})
+        all_follows(options).collect{ |f| f.followable }
+      end
+
+      # Returns the actual records of a particular type which this record is following.
+      def following_by_type(followable_type, options={})
+        followables = followable_type.constantize.
+          joins(:followings).
+          where('follows.blocked'         => false,
+                'follows.follower_id'     => self.id,
+                'follows.follower_type'   => parent_class_name(self),
+                'follows.followable_type' => followable_type)
+        if options.has_key?(:limit)
+          followables = followables.limit(options[:limit])
+        end
+        if options.has_key?(:includes)
+          followables = followables.includes(options[:includes])
+        end
+        followables
+      end
+
+      def following_by_type_count(followable_type)
+        follows.unblocked.for_followable_type(followable_type).count
+      end
+
+      # Allows magic names on following_by_type
+      # e.g. following_users == following_by_type('User')
+      # Allows magic names on following_by_type_count
+      # e.g. following_users_count == following_by_type_count('User')
+      def method_missing(m, *args)
+        if m.to_s[/following_(.+)_count/]
+          following_by_type_count($1.singularize.classify)
+        elsif m.to_s[/following_(.+)/]
+          following_by_type($1.singularize.classify)
+        else
+          super
+        end
+      end
+
+      def respond_to?(m, include_private = false)
+        super || m.to_s[/following_(.+)_count/] || m.to_s[/following_(.+)/]
+      end
+
+      # Returns a follow record for the current instance and followable object.
+      def get_follow(followable)
+        self.follows.unblocked.for_followable(followable).first
+      end
+
+    end
+  end
+end

data/lib/followable_behaviour/follower_lib.rb

@@ -0,0 +1,30 @@
+module FollowableBehaviour
+  module FollowerLib
+
+    private
+
+    # Retrieves the parent class name if using STI.
+    def parent_class_name(obj)
+      obj.class.base_class.name
+    end
+
+    def apply_options_to_scope(scope, options = {})
+      if options.has_key?(:limit)
+        scope = scope.limit(options[:limit])
+      end
+      if options.has_key?(:includes)
+        scope = scope.includes(options[:includes])
+      end
+      if options.has_key?(:joins)
+        scope = scope.joins(options[:joins])
+      end
+      if options.has_key?(:where)
+        scope = scope.where(options[:where])
+      end
+      if options.has_key?(:order)
+        scope = scope.order(options[:order])
+      end
+      scope
+    end
+  end
+end

data/lib/followable_behaviour/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails'
+
+module FollowableBehaviour
+  class Railtie < Rails::Railtie
+
+    initializer "acts_as_follower.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        include FollowableBehaviour::Follower
+        include FollowableBehaviour::Followable
+      end
+    end
+
+  end
+end

data/lib/followable_behaviour/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FollowableBehaviour
+  VERSION = "0.1.0"
+end

data/lib/followable_behaviour.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "followable_behaviour/version"
+
+module FollowableBehaviour
+  class Error < StandardError; end
+  
+  autoload :Follower,     'followable_behaviour/follower'
+  autoload :Followable,   'followable_behaviour/followable'
+  autoload :FollowerLib,  'followable_behaviour/follower_lib'
+  autoload :FollowScopes, 'followable_behaviour/follow_scopes'
+
+  require 'followable_behaviour/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 6
+  
+end

data/lib/generators/USAGE

@@ -0,0 +1,5 @@
+Description:
+    rails generate acts_as_follower
+
+    no need to specify a name after acts_as_follower as you can not change the model name from Follow
+    the acts_as_follower_migration file will be created in db/migrate

data/lib/generators/followable_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class FollowableBehaviourGenerator < Rails::Generators::Base
+  
+  include Rails::Generators::Migration
+  
+  def self.source_root
+    @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+  
+  # Implement the required interface for Rails::Generators::Migration.
+  # taken from https://github.com/rails/rails/blob/master/activerecord/lib/rails/generators/active_record.rb
+  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
+  
+  def create_migration_file
+    migration_template 'migration.rb', 'db/migrate/followable_behaviour_migration.rb'
+  end
+  
+  def create_model
+    template "model.rb", File.join('app/models', "follow.rb")
+  end
+  
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,22 @@
+if ActiveRecord.gem_version >= Gem::Version.new('5.0')
+   class ActsAsFollowerMigration < ActiveRecord::Migration["#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"]; end
+else
+   class ActsAsFollowerMigration < ActiveRecord::Migration; end
+end
+FollowableBehaviourMigration.class_eval do
+def self.up
+    create_table :follows, force: true do |t|
+      t.references :followable, polymorphic: true, null: false
+      t.references :follower,   polymorphic: true, null: false
+      t.boolean :blocked, default: false, null: false
+      t.timestamps
+    end
+
+    add_index :follows, ["follower_id", "follower_type"],     name: "fk_follows"
+    add_index :follows, ["followable_id", "followable_type"], name: "fk_followables"
+  end
+
+  def self.down
+    drop_table :follows
+  end
+end

data/lib/generators/templates/model.rb

@@ -0,0 +1,14 @@
+class Follow < ActiveRecord::Base
+
+  extend FollowableBehaviour::FollowerLib
+  extend FollowableBehaviour::FollowScopes
+
+  # NOTE: Follows belong to the "followable" and "follower" interface
+  belongs_to :followable, polymorphic: true
+  belongs_to :follower,   polymorphic: true
+
+  def block!
+    self.update_attribute(:blocked, true)
+  end
+
+end

data/sig/followable_behaviour.rbs

@@ -0,0 +1,4 @@
+module FollowableBehaviour
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: followable_behaviour
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jean-Baptiste Francois
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: shoulda_create
+  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: shoulda
+  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: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Updated fork of the unmaintained gem acts_as_followers. It was tested
+  with Ruby 3.1.2 and Rails 7
+email:
+- jbpfran@studiosjb.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/followable_behaviour.rb
+- lib/followable_behaviour/follow_scopes.rb
+- lib/followable_behaviour/followable.rb
+- lib/followable_behaviour/follower.rb
+- lib/followable_behaviour/follower_lib.rb
+- lib/followable_behaviour/railtie.rb
+- lib/followable_behaviour/version.rb
+- lib/generators/USAGE
+- lib/generators/followable_generator.rb
+- lib/generators/templates/migration.rb
+- lib/generators/templates/model.rb
+- sig/followable_behaviour.rbs
+homepage: https://gitlab.com/jbpfran/followable-behaviour
+licenses: []
+metadata:
+  homepage_uri: https://gitlab.com/jbpfran/followable-behaviour
+  source_code_uri: https://gitlab.com/jbpfran/followable-behaviour
+  changelog_uri: https://gitlab.com/jbpfran/followable-behaviour/-/blob/main/CHANGELOG
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Updated fork of the unmaintained gem acts_as_followers.
+test_files: []