acts_as_favoritor 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2875795f7875bb8dee5c728af27a406a6808b0eda78a42f0349824362ac3e26
-  data.tar.gz: 1dc45485b56e56d9df9a20f61e1044bbe1dbcf83731dbdf5beeb621aa768cc2e
+  metadata.gz: 184296038ccc8938d320282f82c180549f13e810ce0d33d45e5999960efa437c
+  data.tar.gz: 7b4bbb4d41550563d65da40a205cee21ee9f27bb100c47d99e345140992d1b2f
 SHA512:
-  metadata.gz: bb5ba1b48c7c76ec581ae6b3c65bde08ed91a2946f01a51c5da3c9daf8d744d461ee2973ebae4baf2fdc39f695498f58eeddf8d7a95e9a14d86aeb71e48c6589
-  data.tar.gz: 203b76be7a03c1d133345165e7d014164d2910d326991939e3314951b3f3e15d88a37118f2ece835d7a74906ab7ce1f692c94e1983179b994c3e3c4f4bc6917f
+  metadata.gz: 1aeb504450b30f447c5beb3a480a3f26ab71a3d0786b853276a2e2ec8c4c9c6a87a4d25145ab31f954de3206062600a4e733baa7ac37fff9657bf6fe8bda0235
+  data.tar.gz: 5280a639b92064db05318f2a5b5a3158878e97bb16eb218d2e42f05436ab857e8bdf8fc3528c71f55e9d7d3386652046e8b8e460ecdf3cf7b0327f60dcb6cdca

data/README.md

@@ -95,9 +95,6 @@ user.remove_favorite(book)
 # Whether `user` has marked `book` as his favorite. Returns `true` or `false`.
 user.favorited?(book)
 
-# Total number of favorites by `user`.
-user.favorites_count
-
 # Returnes `user`'s favorites that have not been blocked as an array of `Favorite` records.
 user.all_favorites
 
@@ -113,16 +110,6 @@ user.favorited_by_type('Book')
 # Returns the exact same result as `user.favorited_by_type 'User'`.
 user.favorited_users
 
-# Total number of favorited books by `user`.
-user.favorited_by_type_count('Book')
-
-# Returns the exact same result as `user.favorited_by_type_count 'Book'`.
-user.favorited_books_count
-
-# Returns the Arel scope for favorites.
-# This does not return the actual favorites, just the scope of favorited including the favoritables, essentially: `book.favorites.unblocked.includes(:favoritable)`.
-book.favorites_scoped
-
 # Block a favoritable
 user.block(book)
 
@@ -134,12 +121,6 @@ user.blocked?(book)
 
 # Returns an array including all blocked Favoritable records.
 user.blocks
-
-# Total number of `user`'s favorites blocked.
-user.blocked_favoritables_count
-
-# Whether `user` has favorited, not favorited or blocked `book`. Returns `true`, `nil` or `false`.
-user.favoritable_type(book)
 ```
 
 These methods take an optional hash parameter of ActiveRecord options (`:limit`, `:order`, etc...)
@@ -152,24 +133,12 @@ These methods take an optional hash parameter of ActiveRecord options (`:limit`,
 # Returns all favoritors of a model that `acts_as_favoritable`
 book.favoritors
 
-# Returns the Arel scope for favoritors. This does not return the actual favoritors, just the scope of favorited records including the favoritors, essentially:  `book.favorited.includes(:favoritors)`.
-book.favoritors_scoped
-
-# Total number of favoritors.
-book.favoritors_count
-
 # Returns an array of records with type `User` following `book`.
 book.favoritors_by_type('User')
 
 # Returns the exact same as `book.favoritors_by_type 'User'`.
 book.user_favoritors
 
-# Total number of favoritors with type `User`.
-book.favoritors_by_type_count('User')
-
-# Returns the exact same as `book.favoritors_by_type_count 'User'`.
-book.count_user_favoritors
-
 # Whether `book` has been favorited by `user`. Returns `true` or `false`.
 book.favorited_by?(user)
 
@@ -184,12 +153,6 @@ book.blocked?(user)
 
 # Returns an array including all blocked Favoritor records.
 book.blocks
-
-# Total number of `book`'s favoritors blocked.
-book.blocked_favoritors_count
-
-# Whether `user` has favorited, not favorited or blocked `book`. Returns `true`, `nil` or `false`.
-book.favoritor_type(user)
 ```
 
 These methods take an optional hash parameter of ActiveRecord options (`:limit`, `:order`, etc...)
@@ -229,11 +192,11 @@ You can create new scopes on the fly. Every single method takes `scope` as an op
 So lets see how this works:
 
 ```ruby
-user.favorite(book, scope: [:favorite, :watching])
-user.remove_favorite(book, scope: [:watching])
+user.favorite(book, scopes: [:favorite, :watching])
+user.remove_favorite(book, scopes: [:watching])
 second_user = User.find(2)
-user.favorite(second_user, scope: [:follow])
-book.block(user, scope: [:all]) # applies to all scopes
+user.favorite(second_user, scopes: [:follow])
+book.block(user, scopes: [:all]) # applies to all scopes
 ```
 
 That's simple!
@@ -241,15 +204,15 @@ That's simple!
 When you call a method which returns something while specifying multiple scopes, the method returns the results in a hash with the scopes as keys:
 
 ```ruby
-user.favorited?(book, scope: [:favorite, :watching]) # => { favorite: true, watching: false }
-user.favorited?(book, scope: [:all]) # => true
+user.favorited?(book, scopes: [:favorite, :watching]) # => { favorite: true, watching: false }
+user.favorited?(book, scopes: [:all]) # => true
 ```
 
 `acts_as_favoritor` also provides some handy scopes for you to call on the `Favorite` model:
 
 ```ruby
 # Returns all `Favorite` records where `scope` is `my_scope`
-Favorite.send(my_scope + '_list')
+Favorite.send("#{my_scope}_list")
 
 ## Examples
 ### Returns all `Favorite` records where `scope` is `favorites`
@@ -333,7 +296,7 @@ Tests are written with Shoulda on top of `Test::Unit` with Factory Girl being us
 
 4. Run tests
 
-    `$ bundle exec rake test`
+    `$ bundle exec rspec`
 
 5. Run RuboCop
 

data/lib/acts_as_favoritor.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'acts_as_favoritor/version'
+require_relative 'acts_as_favoritor/version'
 
 module ActsAsFavoritor
-  require 'acts_as_favoritor/configuration'
+  require_relative '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)
+  require_relative 'acts_as_favoritor/railtie' if defined?(Rails::Railtie)
 end

data/lib/acts_as_favoritor/favoritable.rb

@@ -8,100 +8,24 @@ module ActsAsFavoritor
 
     module ClassMethods
       def acts_as_favoritable
-        has_many :favorited,
-                 as: :favoritable, dependent: :destroy, class_name: 'Favorite'
-        include ActsAsFavoritor::Favoritable::InstanceMethods
-        include ActsAsFavoritor::FavoritorLib
+        if ActsAsFavoritor.configuration&.cache
+          serialize :favoritable_score, Hash
+          serialize :favoritable_total, Hash
+        end
 
-        return unless ActsAsFavoritor.configuration&.cache
+        has_many :favorited, as: :favoritable, dependent: :destroy,
+                             class_name: 'Favorite'
 
-        serialize :favoritable_score, Hash
-        serialize :favoritable_total, Hash
+        include ActsAsFavoritor::Favoritable::InstanceMethods
+        include ActsAsFavoritor::FavoritorLib
       end
     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
-
-      # 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 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
-
-      # 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'
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       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
+        if method.to_s[/(.+)_favoritors/]
+          favoritors_by_type($1.singularize.classify)
         elsif ActsAsFavoritor.configuration.cache &&
               method.to_s[/favoritable_(.+)_score/]
           favoritable_score[$1.singularize.classify]
@@ -112,281 +36,76 @@ module ActsAsFavoritor
           super
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def respond_to_missing?(method, include_private = false)
-        super || method.to_s[/count_(.+)_favoritors/] ||
-          method.to_s[/(.+)_favoritors/]
+        super || method.to_s[/(.+)_favoritors/] ||
+          method.to_s[/favoritable_(.+)_score/] ||
+          method.to_s[/favoritable_(.+)_total/]
       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
+      def favoritors(scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          favorited.includes(:favoritor).unblocked.send("#{scope}_list")
+                   .map(&: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)
+      def favoritors_by_type(favoritor_type,
+                             scopes: [ActsAsFavoritor.configuration
+                                                     .default_scope])
+        build_result_for_scopes scopes do |scope|
+          favorited.unblocked.send("#{scope}_list")
+                   .for_favoritor_type(favoritor_type).map(&:favoritor)
         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)
+      def favorited_by?(favoritor,
+                        scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          favorited.unblocked.send("#{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
+      def block(favoritor,
+                scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          get_favorite_for(favoritor, scope).block! || Favorite.create(
+            favoritable: self,
+            favoritor: favoritor,
+            blocked: true,
+            scope: scope
           )
-          blocked_favoritors_scope.to_a.collect(&: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.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?
+      def unblock(favoritor,
+                  scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          get_favorite_for(favoritor, scope)&.update(blocked: 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?
+      def blocked?(favoritor,
+                   scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          favorited.blocked.send("#{scope}_list").for_favoritor(favoritor).first
+                   .present?
         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.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 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
-
-      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 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
+      def blocks(scopes: [ActsAsFavoritor.configuration.default_scope])
+        build_result_for_scopes scopes do |scope|
+          favorited.includes(:favoritor).blocked.send("#{scope}_list")
+                   .map(&:favoritor)
         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
+      def get_favorite_for(favoritor, scope)
+        favorited.send("#{scope}_list").for_favoritor(favoritor).first
       end
     end
   end