followability 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96a742ecd47a5d0cc1f9c5247d991f5da15540fe32f4ed1f5cb340ff42f75560
-  data.tar.gz: d3f37786e80e7d1adbc6e74de84b43f9c2e923208cc3673d3557a2b3baa73f8c
+  metadata.gz: 5381804ee6dcba9d0a7fcd76d2a560e9b6ff371aa3b2c4212cb394f8abbf4468
+  data.tar.gz: 4aae8e97665f8b10f1a1ee31d9b244d1a63fed320d7e9777249c907c215e3d5f
 SHA512:
-  metadata.gz: 990e5646cb61a4300be524bb48e875012daa5faff1362ebf9ba6ed2547a0b66cb323b27e4e882e30a486986750ae201ec6ad858dcf8f35c34a390fb2f07400c6
-  data.tar.gz: 1901bab6ec5670d0337357789fb2e8d82192a469d00e7d5345970e21269435281df397fbd50cf39fdce7b98996eb83e5947c5fe1d5302215b83b1ac3a7f0e4e3
+  metadata.gz: db1fab64911111ec2ef69ca06f4b173f4bd0daf4e49085fcbaae2674c6b1efac9e549ffe492ab2205eee0bc413200c09910094fa4819b914cb92a0bfbe1a6fa5
+  data.tar.gz: fb8e8e23c3b63158ba16e7981d85de9ee0382ee530d3b0de2194feb125e6d6ba5ed209c1c5caa12476814701e50038bd906c1b70fb19b2cc1c808d0b526636d2

data/.rubocop.yml

@@ -20,4 +20,10 @@ Style/Documentation:
 Metrics/MethodLength:
   Enabled: true
   CountComments: false
-  Max: 20
+  Max: 30
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/BlockLength:
+  Max: 30

data/CHANGELOG.md

@@ -1,4 +1,16 @@
-## [Unreleased]
+## [1.0.0] - 2022-10-15
+- Added belowing methods
+  - decline_follow_request_of
+  - remove_follow_request_for
+  - send_follow_request_to
+  - following?
+  - mutual_following_with?
+  - sent_follow_request_to?
+  - block_to
+  - unblock_to
+  - blocked?
+  - blocked_by?
+  - myself?
 
 ## [0.1.0] - 2022-10-14
 

data/Gemfile

@@ -25,3 +25,15 @@ gem 'dry-configurable', '~> 0.15.0'
 
 # Pry is a runtime developer console and IRB alternative with powerful introspection capabilities [https://github.com/pry/pry]
 gem 'pry', '~> 0.14.1'
+
+# A toolkit of support libraries and Ruby core extensions extracted from the Rails framework [https://github.com/rails/rails]
+gem 'activesupport', '>= 5.0', '>= 7.0.4'
+
+# A toolkit for building modeling frameworks like Active Record [https://github.com/rails/rails]
+gem 'activemodel', '>= 5.0', '>= 7.0.4'
+
+# Databases on Rails. Build a persistent domain model by mapping database tables to Ruby classes [https://github.com/rails/rails]
+gem 'activerecord', '>= 5.0', '>= 7.0.4'
+
+# Ruby on Rails is a full-stack web framework optimized for programmer happiness and sustainable productivity [https://github.com/rails/rails]
+gem 'rails', '>= 5.0', '>= 7.0.4'

data/Gemfile.lock

@@ -1,15 +1,82 @@
 PATH
   remote: .
   specs:
-    followability (0.1.0)
+    followability (1.0.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)
     ast (2.4.2)
     awesome_print (1.9.2)
+    builder (3.2.4)
     coderay (1.1.3)
     concurrent-ruby (1.1.10)
+    crass (1.0.6)
     dry-configurable (0.15.0)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.6)
@@ -18,15 +85,68 @@ GEM
     dry-monads (1.4.0)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.7)
+    erubi (1.11.0)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
     json (2.6.2)
+    loofah (2.19.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
     method_source (1.0.0)
+    mini_mime (1.1.2)
     minitest (5.16.3)
+    net-imap (0.3.1)
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.1.3)
+      timeout
+    net-smtp (0.3.2)
+      net-protocol
+    nio4r (2.5.8)
+    nokogiri (1.13.8-arm64-darwin)
+      racc (~> 1.4)
     parallel (1.22.1)
     parser (3.1.2.1)
       ast (~> 2.4.1)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    racc (1.6.0)
+    rack (2.2.4)
+    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.3)
+      loofah (~> 2.3)
+    railties (7.0.4)
+      actionpack (= 7.0.4)
+      activesupport (= 7.0.4)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.6.0)
@@ -44,18 +164,30 @@ GEM
     rubocop-ast (1.21.0)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
+    thor (1.2.1)
+    timeout (0.3.0)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.3.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.1)
 
 PLATFORMS
   arm64-darwin-21
 
 DEPENDENCIES
+  activemodel (>= 7.0.4, >= 5.0)
+  activerecord (>= 7.0.4, >= 5.0)
+  activesupport (>= 7.0.4, >= 5.0)
   awesome_print
   dry-configurable (~> 0.15.0)
   dry-monads (~> 1.4)
   followability!
   minitest (~> 5.0)
   pry (~> 0.14.1)
+  rails (>= 7.0.4, >= 5.0)
   rake (~> 13.0)
   rubocop (~> 1.21)
 

data/README.md

@@ -1,4 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/btc_turk.svg)](https://badge.fury.io/rb/btc_turk)
+[![Gem Version](https://badge.fury.io/rb/followability.svg)](https://badge.fury.io/rb/followability)
 ![test](https://github.com/nejdetkadir/followability/actions/workflows/test.yml/badge.svg?branch=main)
 ![rubocop](https://github.com/nejdetkadir/followability/actions/workflows/rubocop.yml/badge.svg?branch=main)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
@@ -13,15 +13,233 @@ gem 'followability', github: 'nejdetkadir/followability', branch: 'main'
 ```
 
 Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add followability
+```bash
+$ bundle add followability
+```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
+```bash
+$ gem install followability
+```
 
-    $ gem install followability
+Run the generator for creating database migration and copying localization files.
+```bash
+$ rails g followability:install
+```
 
 ## Usage
-TODO: Write usage instructions here
+Simply drop in `followability` to a model:
+
+```ruby
+class User < ActiveRecord::Base
+  followability
+end
+```
+
+Now, instances of `User` have followability.
+```ruby
+User.followability?
+# => true
+```
+
+### Following actions
+Avaiable methods:
+- decline_follow_request_of
+- remove_follow_request_for
+- send_follow_request_to
+- unfollow
+- following?
+- mutual_following_with?
+- sent_follow_request_to?
+
+### Usage
+```ruby
+@foo = User.first
+@bar = User.last
+
+@foo.send_follow_request_to(@bar)
+# => true
+
+@foo.sent_follow_request_to?(@bar)
+# => true
+
+@bar.decline_follow_request_of(@foo)
+# => true
+
+@bar.accept_follow_request_of(@foo)
+# => false
+
+@bar.errors.full_messages
+# => [...]
+
+@foo.remove_follow_request_for(@bar)
+# => false
+
+@foo.errors.full_messages
+# => [...]
+
+@foo.mutual_following_with?(@bar)
+# => false
+
+@bar.following?(@foo)
+# => false
+```
+
+### Blocking actions
+Avaiable methods:
+- block
+- unblock
+- blocked?
+- blocked_by?
+
+### Usage
+```ruby
+@foo.block(@bar)
+# => true
+
+@foo.blocked?(@bar)
+# => true
+
+@bar.blocked_by?(@foo)
+# => true
+
+@foo.unblock(@bar)
+# => true
+```
+
+### Common
+Avaiable methods:
+- myself?
+
+### Usage
+```ruby
+class User < ActiveRecord::Base
+  followability
+  
+  def follow_request_removed_by_someone(record)
+    unless myself?(record)
+      # Do something
+    end
+  end
+end
+```
+
+### Relations
+Avaiable methods:
+- follow_requests
+- pending_requests
+- followerable_relationships
+- followable_relationships
+- followers
+- following
+- blocks
+
+### Usage
+```ruby
+@foo.follow_requests
+# => [#<Followability::Relationship ...>]
+
+@foo.pending_requests
+# => [#<Followability::Relationship ...>]
+
+@foo.followerable_relationships
+# => [#<Followability::Relationship ...>]
+
+@foo.followable_relationships
+# => [#<Followability::Relationship ...>]
+
+@foo.followers
+# => [#<User ...>]
+
+@foo.following
+# => [#<User ...>]
+
+@foo.blocks
+# => [#<User ...>]
+```
+
+### Callback Methods
+Available methods:
+- follow_request_sent_to_me
+- follow_request_sent_to_someone
+- follow_request_accepted_by_me
+- follow_request_accepted_by_someone
+- follow_request_declined_by_me
+- follow_request_declined_by_someone
+- follow_request_removed_by_me
+- follow_request_removed_by_someone
+- followable_blocked_by_me
+- followable_blocked_by_someone
+- followable_unblocked_by_me
+- followable_unblocked_by_someone
+- unfollow_by_me
+- unfollow_by_someone
+- followability_triggered
+
+### Usage
+```ruby
+class User < ActiveRecord::Base
+  followability
+
+  def follow_request_sent_to_me(record)
+    Notifications::FollowRequestSentToMeJob.perform_later(from_id: record.id)
+  end
+
+  def follow_request_sent_to_someone(record); end
+  def follow_request_accepted_by_me(record); end
+  def follow_request_accepted_by_someone(record); end
+  def follow_request_declined_by_me(record); end
+  def follow_request_declined_by_someone(record); end
+  def follow_request_removed_by_me(record); end
+  def follow_request_removed_by_someone(record); end
+  def followable_blocked_by_me(record); end
+  def followable_blocked_by_someone(record); end
+  def followable_unblocked_by_me(record); end
+  def followable_unblocked_by_someone(record); end
+  def unfollow_by_me(record); end
+
+  def unfollow_by_someone(record)
+    Followability::RemoveFollowedUser(user_id: record.id)
+  end
+
+  def followability_triggered(record, callback_name); end
+end
+```
+
+## I18n
+```yml
+---
+en:
+  followability:
+    errors:
+      block:
+        unblock:
+          myself: 'You can not run this action for yourself'
+        block:
+          myself: 'You can not run this action for yourself'
+          blocked_by: 'You can not block to who blocked to you'
+          already_blocked: '%{klass} already blocked'
+          not_blocked_for_blocking: 'You can not unblock to %{klass} because was not blocked'
+      follow:
+        unfollow:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not unfollow to %{klass} because was not followed'
+        decline_follow_request_of:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not decline follow request of %{klass} because was not sent'
+        accept_follow_request_of:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not accept follow request of %{klass} because was not sent'
+        remove_follow_request_for:
+          empty_relation: 'You can not remove follow request of %{klass} because was not sent'
+          myself: 'You can not run this action for yourself'
+        send_follow_request_to:
+          myself: 'You can not run this action for yourself'
+          blocked_by: 'You can not send follow request to who blocked to you'
+          following: 'You are already following to %{klass}'
+          already_sent: 'You are already sent follow request'
+          blocked: 'You can not send follow request to blocked %{klass}'
+```
 
 ## Development
 

data/config/locales/en.yml

@@ -0,0 +1,31 @@
+---
+en:
+  followability:
+    errors:
+      block:
+        unblock:
+          myself: 'You can not run this action for yourself'
+        block:
+          myself: 'You can not run this action for yourself'
+          blocked_by: 'You can not block to who blocked to you'
+          already_blocked: '%{klass} already blocked'
+          not_blocked_for_blocking: 'You can not unblock to %{klass} because was not blocked'
+      follow:
+        unfollow:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not unfollow to %{klass} because was not followed'
+        decline_follow_request_of:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not decline follow request of %{klass} because was not sent'
+        accept_follow_request_of:
+          myself: 'You can not run this action for yourself'
+          empty_relation: 'You can not accept follow request of %{klass} because was not sent'
+        remove_follow_request_for:
+          empty_relation: 'You can not remove follow request of %{klass} because was not sent'
+          myself: 'You can not run this action for yourself'
+        send_follow_request_to:
+          myself: 'You can not run this action for yourself'
+          blocked_by: 'You can not send follow request to who blocked to you'
+          following: 'You are already following to %{klass}'
+          already_sent: 'You are already sent follow request'
+          blocked: 'You can not send follow request to blocked %{klass}'

data/lib/followability/followable/actions/block.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Followability
+  module Followable
+    module Actions
+      module Block
+        I18N_SCOPE = 'followability.errors.block'
+
+        def block(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('block.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          if blocked_by?(record)
+            errors.add(:base, I18n.t('block.blocked_by', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          if blocked?(record)
+            errors.add(:base, I18n.t('block.already_blocked', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = followerable_relationships.blocked.new(followable: record,
+                                                            status: Followability::Relationship.statuses[:blocked])
+
+          if relation.save
+            run_callback(self, affected: record, callback: :followable_blocked_by_me)
+            run_callback(record, affected: self, callback: :followable_blocked_by_someone)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+
+        def unblock(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('unblock.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          unless blocked?(record)
+            errors.add(:base, I18n.t(:not_blocked_for_blocking, scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = followerable_relationships.blocked.find_by(followable: record)
+
+          if relation.destroy
+            run_callback(self, affected: record, callback: :followable_unblocked_by_me)
+            run_callback(record, affected: self, callback: :followable_unblocked_by_someone)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+
+        def blocked?(record)
+          followerable_relationships.blocked.exists?(followable: record)
+        end
+
+        def blocked_by?(record)
+          record.followerable_relationships.blocked.exists?(followable: self)
+        end
+      end
+    end
+  end
+end

data/lib/followability/followable/actions/common.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Followability
+  module Followable
+    module Actions
+      module Common
+        def myself?(record)
+          id == record.id
+        end
+      end
+    end
+  end
+end

data/lib/followability/followable/actions/follow.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module Followability
+  module Followable
+    module Actions
+      module Follow
+        I18N_SCOPE = 'followability.errors.follow'
+
+        def decline_follow_request_of(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('decline_follow_request_of.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = follow_requests.find_by(followerable_id: record.id, followerable_type: record.class.name)
+
+          if relation.blank?
+            errors.add(:base,
+                       I18n.t('decline_follow_request_of.empty_relation', scope: I18N_SCOPE, klass: record.class.name))
+
+            false
+          elsif relation.destroy
+            run_callback(self, affected: record, callback: :follow_request_declined_by_me)
+            run_callback(record, affected: self, callback: :follow_request_declined_by_someone)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+
+        def unfollow(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('unfollow.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          unless following?(record)
+            errors.add(:base, I18n.t('unfollow.not_following', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = followerable_relationships.find_by(followable_id: record.id,
+                                                        followable_type: record.class.name,
+                                                        status: Followable::Relationship.statuses[:following])
+
+          if relation.destroy
+            run_callback(self, affected: record, callback: :unfollow_by_me)
+            run_callback(record, affected: self, callback: :unfollow_by_someone)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages)
+
+            false
+          end
+        end
+
+        def accept_follow_request_of(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('accept_follow_request_of.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = follow_requests.find_by(followerable_id: record.id, followerable_type: record.class.name)
+
+          if relation.blank?
+            errors.add(:base,
+                       I18n.t('accept_follow_request_of.empty_relation', scope: I18N_SCOPE, klass: record.class.name))
+
+            false
+          elsif relation.update(status: Followability::Relationship.statuses[:following])
+            run_callback(record, affected: record, callback: :follow_request_accepted_by_someone)
+            run_callback(self, affected: self, callback: :follow_request_accepted_by_me)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+
+        def remove_follow_request_for(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('remove_follow_request_for.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          relation = pending_requests.find_by(followable_id: record.id, followable_type: record.class.name)
+
+          if relation.blank?
+            errors.add(:base,
+                       I18n.t('remove_follow_request_for.empty_relation', scope: I18N_SCOPE, klass: record.class.name))
+
+            false
+          elsif relation.destroy
+            run_callback(self, affected: record, callback: :follow_request_removed_by_me)
+            run_callback(record, affected: self, callback: :follow_request_removed_by_someone)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def send_follow_request_to(record)
+          if myself?(record)
+            errors.add(:base, I18n.t('send_follow_request_to.myself', scope: I18N_SCOPE, klass: record.class))
+
+            return false
+          end
+
+          if blocked_by?(record)
+            errors.add(:base, I18n.t('send_follow_request_to.blocked_by', scope: I18N_SCOPE, klass: record.class.name))
+
+            return false
+          end
+
+          if following?(record)
+            errors.add(:base,
+                       I18n.t('send_follow_request_to.following', scope: I18N_SCOPE,
+                                                                  klass: pluralize(record.class.name)))
+
+            return false
+          end
+
+          if sent_follow_request_to?(record)
+            errors.add(:base,
+                       I18n.t('send_follow_request_to.already_sent', scope: I18N_SCOPE, klass: record.class.name))
+
+            return false
+          end
+
+          if blocked?(record)
+            errors.add(:base, I18n.t('send_follow_request_to.blocked', scope: I18N_SCOPE, klass: record.class.name))
+
+            return false
+          end
+
+          relation = pending_requests.new(followable: record,
+                                          status: Followability::Relationship.statuses[:requested])
+
+          if relation.save
+            run_callback(self, affected: record, callback: :follow_request_sent_to_someone)
+            run_callback(record, affected: self, callback: :follow_request_sent_to_me)
+
+            true
+          else
+            errors.add(:base, relation.errors.full_messages.to_sentence)
+
+            false
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        def following?(record)
+          following.exists?(id: record.id)
+        end
+
+        def mutual_following_with?(record)
+          following.exists?(id: record.id) && followers.exists?(id: record.id)
+        end
+
+        def sent_follow_request_to?(record)
+          record.follow_requests.exists?(followerable_id: id, followerable_type: self.class.name)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/followability/followable/associations.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Followability
+  module Followable
+    module Associations
+      def follow_requests
+        followable_relationships.requested
+      end
+
+      def pending_requests
+        followerable_relationships.requested
+      end
+    end
+  end
+end

data/lib/followability/followable/callbacks.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Followability
+  module Followable
+    module Callbacks
+      METHOD_NAMES = %i[
+        follow_request_sent_to_someone
+        follow_request_sent_to_me
+        follow_request_accepted_by_me
+        follow_request_accepted_by_someone
+        follow_request_declined_by_me
+        follow_request_declined_by_someone
+        follow_request_removed_by_me
+        follow_request_removed_by_someone
+        followable_blocked_by_me
+        followable_blocked_by_someone
+        followable_unblocked_by_me
+        followable_unblocked_by_someone
+        unfollow_by_me
+        unfollow_by_someone
+        followability_triggered
+      ].freeze
+
+      def run_callback(record, callback:, affected:)
+        raise ArgumentError if METHOD_NAMES.exclude?(callback) || callback.eql?(:followability_triggered)
+
+        [callback, :followability_triggered].each do |cb_name|
+          record.send(cb_name, affected, cb_name) if record.respond_to?(cb_name)
+        end
+      end
+    end
+  end
+end

data/lib/followability/followable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Followability
+  module Followable
+    def followability?
+      false
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def followability
+      class_eval do
+        def self.followability?
+          true
+        end
+
+        has_many :followerable_relationships,
+                 as: :followerable,
+                 class_name: 'Followability::Relationship',
+                 dependent: :destroy
+
+        has_many :followable_relationships,
+                 as: :followable,
+                 class_name: 'Followability::Relationship',
+                 dependent: :destroy
+
+        has_many :followers,
+                 -> { Followability::Relationship.following },
+                 through: :followable_relationships,
+                 source: :followerable,
+                 class_name: name,
+                 source_type: name
+
+        has_many :following,
+                 -> { Followability::Relationship.following },
+                 through: :followerable_relationships,
+                 source: :followable,
+                 class_name: name,
+                 source_type: name
+
+        has_many :blocks,
+                 -> { Followability::Relationship.blocked },
+                 through: :followerable_relationships,
+                 source: :followable,
+                 class_name: name,
+                 source_type: name
+      end
+
+      include Followability::Followable::Associations
+      include Followability::Followable::Callbacks
+      include Followability::Followable::Actions::Common
+      include Followability::Followable::Actions::Follow
+      include Followability::Followable::Actions::Block
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/followability/generators/install_generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module Followability
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def create_migration
+        invoke 'migration', migration_args
+        copy_file locale_source, locale_destination
+      end
+
+      def fields_command
+        %w[
+          followerable:belongs_to{polymorphic}
+          followable:belongs_to{polymorphic}
+          status:integer
+        ]
+      end
+
+      def locale_source
+        File.expand_path('../../../config/locales/en.yml', __dir__)
+      end
+
+      def locale_destination
+        'config/locales/followability.en.yml'
+      end
+
+      def migration_name
+        'CreateFollowabilityRelationships'
+      end
+
+      def migration_args
+        [migration_name].concat(fields_command)
+      end
+    end
+  end
+end

data/lib/followability/relationship.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Followability
+  class Relationship < ActiveRecord::Base
+    STATUSES = %i[requested blocked following].freeze
+
+    enum status: STATUSES
+
+    validates :status, presence: true
+
+    belongs_to :followerable, polymorphic: true, optional: false
+    belongs_to :followable, polymorphic: true, optional: false
+
+    def self.table_name_prefix
+      'followability_'
+    end
+  end
+end

data/lib/followability/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Followability
-  VERSION = '0.1.0'
+  VERSION = '1.1.0'
 end

data/lib/followability.rb

@@ -1,8 +1,23 @@
 # frozen_string_literal: true
 
 require_relative 'followability/version'
+require 'active_support'
+require 'active_record'
+require 'active_model'
 
 module Followability
-  class Error < StandardError; end
-  # Your code goes here...
+  extend ActiveSupport::Autoload
+
+  require_relative 'followability/followable/associations'
+  require_relative 'followability/followable/callbacks'
+  require_relative 'followability/followable/actions/common'
+  require_relative 'followability/followable/actions/follow'
+  require_relative 'followability/followable/actions/block'
+  require_relative 'followability/followable'
+  require_relative 'followability/relationship'
+  require_relative 'followability/generators/install_generator'
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend Followability::Followable
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: followability
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - nejdetkadir
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-14 00:00:00.000000000 Z
+date: 2022-10-17 00:00:00.000000000 Z
 dependencies: []
 description: Implements the social network followable functionality for your Active
   Record models.
@@ -27,8 +27,17 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- config/locales/en.yml
 - followability.gemspec
 - lib/followability.rb
+- lib/followability/followable.rb
+- lib/followability/followable/actions/block.rb
+- lib/followability/followable/actions/common.rb
+- lib/followability/followable/actions/follow.rb
+- lib/followability/followable/associations.rb
+- lib/followability/followable/callbacks.rb
+- lib/followability/generators/install_generator.rb
+- lib/followability/relationship.rb
 - lib/followability/version.rb
 - sig/followability.rbs
 homepage: https://github.com/nejdetkadir/followability