acts_as_favoritor 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bda840e48829f86862b98f8bb559cd9d7310352af4edc26173d6b5b44ee815a
-  data.tar.gz: d7e99df4d9541794b1c1d2828e6c0b024625cbe5c5ddb51f1158714ff62eeb87
+  metadata.gz: 7ff8778bb55338480286174f66774251914fa4ef19aabb79dd5588d3c6bf40dc
+  data.tar.gz: 239c8bfbacb746ac449a4682ec731adf4c85da8493d983bd210627c0ebd105bd
 SHA512:
-  metadata.gz: eeb4bdf4c2443059da696a58d65055d4f06e9b233d469a383f13a243239b4e19b61dfd9a039ab234c3af85dd2191d91fc72ce61b596a227752038c9a689a73e7
-  data.tar.gz: 9f92498cab6a74bbe770b6551aff0e77920a6e9e7f400174298a59578de80cc8d90b6442f80f6d772c2490732a1236e0e88cbe45db30b6aa3c7b19290d398220
+  metadata.gz: 262b98216f3e58c124de01bf1e78b29a8aceca911cb46726996e51d2fa7f43162a8f9100d17fc359c7bbb9faa427a58d8973d73de4c7979cafe981385880e931
+  data.tar.gz: 025be50ca7f9b0e3671a999a1e385ee6c2b2d89a7f339073d9d82c0c44550adc95cc0818ab5509b6e6f6f4156ff83771dfccd7f969566111bac0733312cb4134

data/README.md

@@ -1,6 +1,6 @@
 # acts_as_favoritor
 
-[![Gem Version](https://badge.fury.io/rb/acts_as_favoritor.svg)](https://badge.fury.io/rb/acts_as_favoritor) <img src="https://travis-ci.org/jonhue/acts_as_favoritor.svg?branch=master" />
+[![Gem Version](https://badge.fury.io/rb/acts_as_favoritor.svg)](https://badge.fury.io/rb/acts_as_favoritor) ![Travis](https://travis-ci.org/jonhue/acts_as_favoritor.svg?branch=master)
 
 acts_as_favoritor is a Rubygem to allow any ActiveRecord model to associate any other model including the option for multiple relationships per association with scopes.
 
@@ -12,20 +12,17 @@ You are able to differentiate followers, favorites, watchers, votes and whatever
 
 * [Installation](#installation)
 * [Usage](#usage)
-    * [Setup](#setup)
-    * [`acts_as_favoritor` methods](#acts_as_favoritor-methods)
-    * [`acts_as_favoritable` methods](#acts_as_favoritable-methods)
-    * [`Favorite` model](#favorite-model)
-    * [Scopes](#scopes)
-    * [Caching](#caching)
+  * [Setup](#setup)
+  * [`acts_as_favoritor` methods](#acts_as_favoritor-methods)
+  * [`acts_as_favoritable` methods](#acts_as_favoritable-methods)
+  * [`Favorite` model](#favorite-model)
+  * [Scopes](#scopes)
+  * [Caching](#caching)
 * [Configuration](#configuration)
 * [Testing](#testing)
-    * [Test Coverage](#test-coverage)
-* [To Do](#to-do)
+* [To do](#to-do)
 * [Contributing](#contributing)
-    * [Contributors](#contributors)
-    * [Semantic versioning](#semantic-versioning)
-* [License](#license)
+  * [Semantic versioning](#semantic-versioning)
 
 ---
 
@@ -67,11 +64,11 @@ Add `acts_as_favoritable` to the models you want to be able to get favorited:
 
 ```ruby
 class User < ActiveRecord::Base
-    acts_as_favoritable
+  acts_as_favoritable
 end
 
 class Book < ActiveRecord::Base
-    acts_as_favoritable
+  acts_as_favoritable
 end
 ```
 
@@ -79,7 +76,7 @@ Specify which models can favorite other models by adding `acts_as_favoritor`:
 
 ```ruby
 class User < ActiveRecord::Base
-    acts_as_favoritor
+  acts_as_favoritor
 end
 ```
 
@@ -314,7 +311,7 @@ You can configure acts_as_favoritor by passing a block to `configure`. This can
 
 ```ruby
 ActsAsFavoritor.configure do |config|
-    config.default_scope = 'follow'
+  config.default_scope = 'follow'
 end
 ```
 
@@ -338,21 +335,15 @@ Tests are written with Shoulda on top of `Test::Unit` with Factory Girl being us
 
     `$ rake test`
 
-### Test Coverage
+5. Run RuboCop
 
-Test coverage can be calculated using SimpleCov. Make sure you have the [simplecov gem](https://github.com/colszowka/simplecov) installed.
-
-1. Uncomment SimpleCov in the Gemfile
-2. Uncomment the relevant section in `test/test_helper.rb`
-3. Run tests
-
-    `$ rake test`
+    `$ bundle exec rubocop`
 
 ---
 
-## To Do
+## To do
 
-[Here](https://github.com/jonhue/acts_as_favoritor/projects/1) is the full list of current projects.
+We use [GitHub projects](https://github.com/jonhue/acts_as_favoritor/projects/1) to coordinate the work on this project.
 
 To propose your ideas, initiate the discussion by adding a [new issue](https://github.com/jonhue/acts_as_favoritor/issues/new).
 
@@ -362,38 +353,8 @@ To propose your ideas, initiate the discussion by adding a [new issue](https://g
 
 We hope that you will consider contributing to acts_as_favoritor. Please read this short overview for some information about how to get started:
 
-[Learn more about contributing to this repository](https://github.com/jonhue/acts_as_favoritor/blob/master/CONTRIBUTING.md), [Code of Conduct](https://github.com/jonhue/acts_as_favoritor/blob/master/CODE_OF_CONDUCT.md)
-
-### Contributors
-
-Give the people some :heart: who are working on this project. See them all at:
-
-https://github.com/jonhue/acts_as_favoritor/graphs/contributors
+[Learn more about contributing to this repository](CONTRIBUTING.md), [Code of Conduct](CODE_OF_CONDUCT.md)
 
 ### Semantic Versioning
 
 acts_as_favoritor follows Semantic Versioning 2.0 as defined at http://semver.org.
-
-## License
-
-MIT License
-
-Copyright (c) 2017 Jonas Hübotter
-
-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/lib/acts_as_favoritor.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 require 'acts_as_favoritor/version'
 
 module ActsAsFavoritor
+  require 'acts_as_favoritor/configuration'
 
-    require 'acts_as_favoritor/configuration'
-
-    autoload :Favoritor, 'acts_as_favoritor/favoritor'
-    autoload :Favoritable, 'acts_as_favoritor/favoritable'
-    autoload :FavoritorLib, 'acts_as_favoritor/favoritor_lib'
-    autoload :FavoriteScopes, 'acts_as_favoritor/favorite_scopes'
-
-    require 'acts_as_favoritor/railtie' if defined?(Rails::Railtie)
+  autoload :Favoritor, 'acts_as_favoritor/favoritor'
+  autoload :Favoritable, 'acts_as_favoritor/favoritable'
+  autoload :FavoritorLib, 'acts_as_favoritor/favoritor_lib'
+  autoload :FavoriteScopes, 'acts_as_favoritor/favorite_scopes'
 
+  require 'acts_as_favoritor/railtie' if defined?(Rails::Railtie)
 end

data/lib/acts_as_favoritor/configuration.rb

@@ -1,23 +1,22 @@
-module ActsAsFavoritor
-
-    class << self
-        attr_accessor :configuration
-    end
-
-    def self.configure
-        self.configuration ||= Configuration.new
-        yield configuration
-    end
-    
-    class Configuration
-
-        attr_accessor :default_scope
-        attr_accessor :cache
-
-        def initialize
-            @default_scope = 'favorite'
-            @cache = false
-        end
-
-    end
-end
+# frozen_string_literal: true
+
+module ActsAsFavoritor
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield configuration
+  end
+
+  class Configuration
+    attr_accessor :default_scope
+    attr_accessor :cache
+
+    def initialize
+      @default_scope = 'favorite'
+      @cache = false
+    end
+  end
+end

data/lib/acts_as_favoritor/favoritable.rb

@@ -1,319 +1,392 @@
+# frozen_string_literal: true
+
 module ActsAsFavoritor
-    module Favoritable
+  module Favoritable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-        def self.included base
-            base.extend ClassMethods
-        end
+    module ClassMethods
+      def acts_as_favoritable
+        has_many :favorited,
+                 as: :favoritable, dependent: :destroy, class_name: 'Favorite'
+        include ActsAsFavoritor::Favoritable::InstanceMethods
+        include ActsAsFavoritor::FavoritorLib
 
-        module ClassMethods
-            def acts_as_favoritable
-                has_many :favorited, as: :favoritable, dependent: :destroy, class_name: 'Favorite'
-                include ActsAsFavoritor::Favoritable::InstanceMethods
-                include ActsAsFavoritor::FavoritorLib
+        return unless ActsAsFavoritor.configuration.cache
+        serialize :favoritable_score, Hash
+        serialize :favoritable_total, Hash
+      end
+    end
 
-                serialize :favoritable_cache, Hash if ActsAsFavoritor.configuration.cache
-            end
+    module InstanceMethods
+      # Returns the number of favoritors a record has.
+      def favoritors_count(options = {})
+        if options.key?(:multiple_scopes) == false
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.unblocked.send(scope + '_list').count
+          end
+          results
+        else
+          favorited.unblocked.send(options[:scope] + '_list').count
         end
+      end
 
-        module InstanceMethods
-
-            # Returns the number of favoritors a record has.
-            def favoritors_count options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.unblocked.send(scope + '_list').count
-                    end
-                    return results
-                else
-                    return favorited.unblocked.send(options[:scope] + '_list').count
-                end
-            end
-
-            # Returns the favoritors by a given type
-            def favoritors_by_type favoritor_type, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor_type
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        favorites = favoritor_type.constantize.joins(:favorites).where('favorites.blocked': false,
-                            'favorites.favoritable_id': id,
-                            'favorites.favoritable_type': parent_class_name(self),
-                            'favorites.favoritor_type': favoritor_type,
-                            'favorites.scope': scope)
-                        if options.has_key? :limit
-                            favorites = favorites.limit options[:limit]
-                        end
-                        if options.has_key? :includes
-                            favorites = favorites.includes options[:includes]
-                        end
-                        results[scope] = favorites
-                    end
-                    return results
-                else
-                    favorites = favoritor_type.constantize.joins(:favorites).where('favorites.blocked': false,
-                        'favorites.favoritable_id': id,
-                        'favorites.favoritable_type': parent_class_name(self),
-                        'favorites.favoritor_type': favoritor_type,
-                        'favorites.scope': options[:scope])
-                    if options.has_key? :limit
-                        favorites = favorites.limit options[:limit]
-                    end
-                    if options.has_key? :includes
-                        favorites = favorites.includes options[:includes]
-                    end
-                    return favorites
-                end
-            end
-
-            def favoritors_by_type_count favoritor_type, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor_type
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.unblocked.send(scope + '_list').for_favoritor_type(favoritor_type).count
-                    end
-                    return results
-                else
-                    return favorited.unblocked.send(options[:scope] + '_list').for_favoritor_type(favoritor_type).count
-                end
-            end
-
-            # Allows magic names on favoritors_by_type
-            # e.g. user_favoritors == favoritors_by_type 'User'
-            # Allows magic names on favoritors_by_type_count
-            # e.g. count_user_favoritors == favoritors_by_type_count 'User'
-            def method_missing m, *args
-                if m.to_s[/count_(.+)_favoritors/]
-                    favoritors_by_type_count $1.singularize.classify
-                elsif m.to_s[/(.+)_favoritors/]
-                    favoritors_by_type $1.singularize.classify
-                elsif m.to_s[/favoritable_(.+)_score/]
-                    favoritable_score[$1.singularize.classify] if ActsAsFavoritor.configuration.cache
-                elsif m.to_s[/favoritable_(.+)_total/]
-                    favoritable_total[$1.singularize.classify] if ActsAsFavoritor.configuration.cache
-                else
-                    super
-                end
+      # Returns the favoritors by a given type.
+      def favoritors_by_type(favoritor_type, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor_type
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            favorites = favoritor_type.constantize.joins(:favorites)
+            favorites = favorites.where(
+              'favorites.blocked': false,
+              'favorites.favoritable_id': id,
+              'favorites.favoritable_type': parent_class_name(self),
+              'favorites.favoritor_type': favoritor_type,
+              'favorites.scope': scope
+            )
+            favorites = favorites.limit(options[:limit]) if options.key?(:limit)
+            if options.key?(:includes)
+              favorites = favorites.includes(options[:includes])
             end
+            results[scope] = favorites
+          end
+          results
+        else
+          favorites = favoritor_type.constantize.joins(:favorites)
+          favorites = favorites.where(
+            'favorites.blocked': false,
+            'favorites.favoritable_id': id,
+            'favorites.favoritable_type': parent_class_name(self),
+            'favorites.favoritor_type': favoritor_type,
+            'favorites.scope': options[:scope]
+          )
+          favorites = favorites.limit(options[:limit]) if options.key?(:limit)
+          if options.key?(:includes)
+            favorites = favorites.includes(options[:includes])
+          end
+          favorites
+        end
+      end
 
-            def respond_to? m, include_private = false
-                super || m.to_s[/count_(.+)_favoritors/] || m.to_s[/(.+)_favoritors/]
-            end
+      def favoritors_by_type_count(favoritor_type, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor_type
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.unblocked.send(scope + '_list')
+                                      .for_favoritor_type(favoritor_type).count
+          end
+          results
+        else
+          favorited.unblocked.send(options[:scope] + '_list')
+                   .for_favoritor_type(favoritor_type).count
+        end
+      end
 
-            def blocked_favoritors_count options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.blocked.send(scope + '_list').count
-                    end
-                    return results
-                else
-                    return favorited.blocked.send(options[:scope] + '_list').count
-                end
-            end
+      # Allows magic names on favoritors_by_type
+      # e.g. user_favoritors == favoritors_by_type 'User'
+      # Allows magic names on favoritors_by_type_count
+      # e.g. count_user_favoritors == favoritors_by_type_count 'User'
+      def method_missing(method, *args)
+        if method.to_s[/count_(.+)_favoritors/]
+          favoritors_by_type_count $1.singularize.classify
+        elsif method.to_s[/(.+)_favoritors/]
+          favoritors_by_type $1.singularize.classify
+        elsif ActsAsFavoritor.configuration.cache &&
+              method.to_s[/favoritable_(.+)_score/]
+          favoritable_score[$1.singularize.classify]
+        elsif ActsAsFavoritor.configuration.cache &&
+              method.to_s[/favoritable_(.+)_total/]
+          favoritable_total[$1.singularize.classify]
+        else
+          super
+        end
+      end
 
-            # Returns the favorited records scoped
-            def favoritors_scoped options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.send(scope + '_list').includes :favoritor
-                    end
-                    return results
-                else
-                    return favorited.send(options[:scope] + '_list').includes :favoritor
-                end
-            end
+      def respond_to_missing?(method, include_private = false)
+        super || method.to_s[/count_(.+)_favoritors/] ||
+          method.to_s[/(.+)_favoritors/]
+      end
 
-            def favoritors options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        favoritors_scope = favoritors_scoped(scope: scope, multiple_scopes: false).unblocked
-                        favoritors_scope = apply_options_to_scope favoritors_scope, options
-                        results[scope] = favoritors_scope.to_a.collect{ |f| f.favoritor }
-                    end
-                    return results
-                else
-                    favoritors_scope = favoritors_scoped(scope: options[:scope], multiple_scopes: false).unblocked
-                    favoritors_scope = apply_options_to_scope favoritors_scope, options
-                    return favoritors_scope.to_a.collect{ |f| f.favoritor }
-                end
-            end
+      def blocked_favoritors_count(options = {})
+        if options.key?(:multiple_scopes) == false
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.blocked.send(scope + '_list').count
+          end
+          results
+        else
+          favorited.blocked.send(options[:scope] + '_list').count
+        end
+      end
 
-            def blocks options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        blocked_favoritors_scope = favoritors_scoped(scope: scope, multiple_scopes: false).blocked
-                        blocked_favoritors_scope = apply_options_to_scope blocked_favoritors_scope, options
-                        results[scope] = blocked_favoritors_scope.to_a.collect{ |f| f.favoritor }
-                    end
-                    return results
-                else
-                    blocked_favoritors_scope = favoritors_scoped(scope: options[:scope], multiple_scopes: false).blocked
-                    blocked_favoritors_scope = apply_options_to_scope blocked_favoritors_scope, options
-                    return blocked_favoritors_scope.to_a.collect{ |f| f.favoritor }
-                end
-            end
+      # Returns the favorited records scoped.
+      def favoritors_scoped(options = {})
+        if options.key?(:multiple_scopes) == false
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.send(scope + '_list')
+                                      .includes(:favoritor)
+          end
+          results
+        else
+          favorited.send(options[:scope] + '_list').includes(:favoritor)
+        end
+      end
 
-            # Returns true if the current instance has blocked the passed record
-            # Returns false if the current instance has not blocked the passed record
-            def blocked? favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.blocked.send(scope + '_list').for_favoritor(favoritor).first.present?
-                    end
-                    return results
-                else
-                    return favorited.blocked.send(options[:scope] + '_list').for_favoritor(favoritor).first.present?
-                end
-            end
+      def favoritors(options = {})
+        if options.key?(:multiple_scopes) == false
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            favoritors_scope = favoritors_scoped(
+              scope: scope, multiple_scopes: false
+            ).unblocked
+            favoritors_scope = apply_options_to_scope(
+              favoritors_scope, options
+            )
+            results[scope] = favoritors_scope.to_a.collect(&:favoritor)
+          end
+          results
+        else
+          favoritors_scope = favoritors_scoped(
+            scope: options[:scope], multiple_scopes: false
+          ).unblocked
+          favoritors_scope = apply_options_to_scope(
+            favoritors_scope, options
+          )
+          favoritors_scope.to_a.collect(&:favoritor)
+        end
+      end
 
-            # Returns true if the current instance is favorited by the passed record
-            # Returns false if the current instance is blocked by the passed record or no favorite is found
-            def favorited_by? favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.unblocked.send(scope + '_list').for_favoritor(favoritor).first.present?
-                    end
-                    return results
-                else
-                    return favorited.unblocked.send(options[:scope] + '_list').for_favoritor(favoritor).first.present?
-                end
-            end
+      def blocks(options = {})
+        if options.key?(:multiple_scopes) == false
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            blocked_favoritors_scope = favoritors_scoped(
+              scope: scope, multiple_scopes: false
+            ).blocked
+            blocked_favoritors_scope = apply_options_to_scope(
+              blocked_favoritors_scope, options
+            )
+            results[scope] = blocked_favoritors_scope.to_a.collect(&:favoritor)
+          end
+          results
+        else
+          blocked_favoritors_scope = favoritors_scoped(
+            scope: options[:scope], multiple_scopes: false
+          ).blocked
+          blocked_favoritors_scope = apply_options_to_scope(
+            blocked_favoritors_scope, options
+          )
+          blocked_favoritors_scope.to_a.collect(&:favoritor)
+        end
+      end
 
-            # Returns true if this instance has been favorited by the object passed as an argument.
-            # Returns nil if this instance has not been favorited by the object passed as an argument.
-            # Returns false if this instance has blocked the object passed as an argument.
-            def favoritor_type favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        if favorited.unblocked.send(scope + '_list').for_favoritor(favoritor).first.present?
-                            results[scope] = true
-                        elsif favorited.blocked.send(scope + '_list').for_favoritor(favoritor).first.present?
-                            results[scope] = false
-                        else
-                            results[scope] = nil
-                        end
-                    end
-                    return results
-                else
-                    if favorited.unblocked.send(options[:scope] + '_list').for_favoritor(favoritor).first.present?
-                        return true
-                    elsif favorited.blocked.send(options[:scope] + '_list').for_favoritor(favoritor).first.present?
-                        return false
-                    else
-                        return nil
-                    end
-                end
-            end
+      # Returns true if the current instance has blocked the passed record.
+      # Returns false if the current instance has not blocked the passed record.
+      def blocked?(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.blocked.send(scope + '_list')
+                                      .for_favoritor(favoritor).first.present?
+          end
+          results
+        else
+          favorited.blocked.send(options[:scope] + '_list')
+                   .for_favoritor(favoritor).first.present?
+        end
+      end
 
-            def block favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = get_favorite_for(favoritor, scope: scope, multiple_scopes: false) ? block_existing_favorite(favoritor, scope: scope, multiple_scopes: false) : block_future_favorite(favoritor, scope: scope, multiple_scopes: false)
-                    end
-                    return results
-                else
-                    return get_favorite_for(favoritor, scope: options[:scope], multiple_scopes: false) ? block_existing_favorite(favoritor, scope: options[:scope], multiple_scopes: false) : block_future_favorite(favoritor, scope: options[:scope], multiple_scopes: false)
-                end
-            end
+      # Returns true if the current instance is favorited by the passed record.
+      # Returns false if the current instance is blocked by the passed record or
+      # no favorite is found.
+      def favorited_by?(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.unblocked.send(scope + '_list')
+                                      .for_favoritor(favoritor).first.present?
+          end
+          results
+        else
+          favorited.unblocked.send(options[:scope] + '_list')
+                   .for_favoritor(favoritor).first.present?
+        end
+      end
 
-            def unblock favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = get_favorite_for(favoritor, scope: scope, multiple_scopes: false)&.update_attribute :blocked, false
-                    end
-                    return results
-                else
-                    return get_favorite_for(favoritor, scope: options[:scope], multiple_scopes: false)&.update_attribute :blocked, false
-                end
+      # Returns true if this instance has been favorited by the object passed as
+      # an argument. Returns nil if this instance has not been favorited by the
+      # object passed as an argument. Returns false if this instance has blocked
+      # the object passed as an argument.
+      def favoritor_type(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            if favorited.unblocked.send(scope + '_list')
+                        .for_favoritor(favoritor).first.present?
+              results[scope] = true
+            elsif favorited.blocked.send(scope + '_list')
+                           .for_favoritor(favoritor).first.present?
+              results[scope] = false
+            else
+              results[scope] = nil
             end
+          end
+          results
+        elsif favorited.unblocked.send(options[:scope] + '_list')
+                       .for_favoritor(favoritor).first.present?
+          true
+        elsif favorited.blocked.send(options[:scope] + '_list')
+                       .for_favoritor(favoritor).first.present?
+          false
+        end
+      end
 
-            def get_favorite_for favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false &&
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = favorited.send(scope + '_list').for_favoritor(favoritor).first
-                    end
-                    return results
-                else
-                    return favorited.send(options[:scope] + '_list').for_favoritor(favoritor).first
-                end
-            end
+      def block(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            favorite = get_favorite_for(
+              favoritor, scope: scope, multiple_scopes: false
+            )
+            results[scope] = if favorite
+                               block_existing_favorite(
+                                 favoritor, scope: scope, multiple_scopes: false
+                               )
+                             else
+                               block_future_favorite(
+                                 favoritor, scope: scope, multiple_scopes: false
+                               )
+                             end
+          end
+          results
+        else
+          favorite = get_favorite_for(
+            favoritor, scope: options[:scope], multiple_scopes: false
+          )
+          if favorite
+            block_existing_favorite(
+              favoritor, scope: options[:scope], multiple_scopes: false
+            )
+          else
+            block_future_favorite(
+              favoritor, scope: options[:scope], multiple_scopes: false
+            )
+          end
+        end
+      end
 
-            private
+      def unblock(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = get_favorite_for(
+              favoritor, scope: scope, multiple_scopes: false
+            )&.update(blocked: false)
+          end
+          results
+        else
+          get_favorite_for(
+            favoritor, scope: options[:scope], multiple_scopes: false
+          )&.update(blocked: false)
+        end
+      end
 
-            def block_future_favorite favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = Favorite.create favoritable: self, favoritor: favoritor, blocked: true, scope: scope
-                    end
-                    return results
-                else
-                    return Favorite.create favoritable: self, favoritor: favoritor, blocked: true, scope: options[:scope]
-                end
-            end
+      def get_favorite_for(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = favorited.send(scope + '_list')
+                                      .for_favoritor(favoritor).first
+          end
+          results
+        else
+          favorited.send(options[:scope] + '_list').for_favoritor(favoritor)
+                   .first
+        end
+      end
 
-            def block_existing_favorite favoritor, options = {}
-                if options.has_key?(:multiple_scopes) == false
-                    options[:parameter] = favoritor
-                    validate_scopes __method__, options
-                elsif options[:multiple_scopes]
-                    results = {}
-                    options[:scope].each do |scope|
-                        results[scope] = get_favorite_for(favoritor, scope: scope, multiple_scopes: false).block!
-                    end
-                    return results
-                else
-                    return get_favorite_for(favoritor, scope: options[:scope], multiple_scopes: false).block!
-                end
-            end
+      private
 
+      def block_future_favorite(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = Favorite.create(
+              favoritable: self,
+              favoritor: favoritor,
+              blocked: true,
+              scope: scope
+            )
+          end
+          results
+        else
+          Favorite.create(
+            favoritable: self,
+            favoritor: favoritor,
+            blocked: true,
+            scope: options[:scope]
+          )
         end
+      end
 
+      def block_existing_favorite(favoritor, options = {})
+        if options.key?(:multiple_scopes) == false
+          options[:parameter] = favoritor
+          validate_scopes(__method__, options)
+        elsif options[:multiple_scopes]
+          results = {}
+          options[:scope].each do |scope|
+            results[scope] = get_favorite_for(
+              favoritor, scope: scope, multiple_scopes: false
+            ).block!
+          end
+          results
+        else
+          get_favorite_for(
+            favoritor, scope: options[:scope], multiple_scopes: false
+          ).block!
+        end
+      end
     end
+  end
 end