acts_as_favoritor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa5428168c7b8609f60f208889cdc00039ec182e
+  data.tar.gz: 0c44c7a38d6a165069afa96cba0eeff74eee1d16
+SHA512:
+  metadata.gz: 675ee97d8c2d37bd81627d738fa629eff5dff73558962b8e3e3862f4095ca420b278e000a066ad06cc8182d5d25a2143ba693f2a78e747b863b87d4c36d0a73a
+  data.tar.gz: 64e88864d50a179520792857dfcdb70f9b759f3097b92a23271f02b709d59bbd8d0722986872255613d2085f7a3de289aa4b13e6c34a05f15d1c4ecbcd273408

data/.gitignore

@@ -0,0 +1,8 @@
+test/debug.log
+coverage
+rdoc
+memory
+*.gem
+.rvmrc
+Gemfile.lock
+log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+    - 2.3.3
+install: bundle install --without development --deployment --jobs=3 --retry=3

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gemspec
+
+
+gem 'activesupport', ENV['RAILS_VERSION'] if ENV['RAILS_VERSION']

data/LICENSE

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

data/README.md

@@ -0,0 +1,73 @@
+# acts_as_favoitor - Add Favorites to you Rails app
+
+<img src="https://travis-ci.org/slooob/acts_as_favoritor.svg?branch=master" />
+
+acts_as_favoritor is a Rubygem to allow any ActiveRecord model to favorite any other model. This is accomplished through a double polymorphic relationship on the Favorite model. There is also built in support for blocking/un-blocking favorite records.
+
+---
+
+## Installation
+
+acts_as_favoritor works with Rails 4.0 onwards. You can add it to your `Gemfile` with:
+
+```ruby
+gem 'acts_as_favoritor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install acts_as_favoritor
+
+If you always want to be up to date fetch the latest from GitHub in your `Gemfile`:
+
+```ruby
+gem 'amphtml', github: 'slooob/acts_as_favoritor'
+```
+
+Now run the generator:
+
+    $ rails g acts_as_favoritor
+
+    $ rails db:migrate
+
+This will create a Favorite model as well as a migration file.
+
+**Note:** Use `rake db:migrate` instead if you run Rails < 5.
+
+## Usage
+
+---
+
+## Contributors
+
+Give the people some :heart: who are working on this project. Check them all at:
+
+https://github.com/slooob/acts_as_favoritor/graphs/contributors
+
+## 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/Rakefile

@@ -0,0 +1,37 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task default: :test
+
+desc 'Test the acts_as_favoritor gem.'
+Rake::TestTask.new(:test) do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_favoritor gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title    = 'Acts As Favoritor'
+    rdoc.main     = 'README.rdoc'
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
+end
+
+namespace :rcov do
+    desc "Generate a coverage report in coverage/"
+    task :gen do
+        sh "rcov --output coverage test/*_test.rb --exclude 'gems/*'"
+    end
+
+    desc "Remove generated coverage files."
+    task :clobber do
+        sh "rm -rdf coverage"
+    end
+end

data/acts_as_favoritor.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'acts_as_favoritor/version'
+
+Gem::Specification.new do |s|
+    s.name        = 'acts_as_favoritor'
+    s.version     = ActsAsFavoritor::VERSION
+    s.authors     = ['Jonas Hübotter']
+    s.email       = ['developer@slooob.com']
+    s.homepage    = 'https://github.com/slooob/acts_as_favoritor'
+    s.summary     = 'A Rubygem to add Favorite functionality for ActiveRecord models'
+    s.description = 'acts_as_favoritor is a Rubygem to allow any ActiveRecord model to favorite any other model. This is accomplished through a double polymorphic relationship on the Favorite model. There is also built in support for blocking/un-blocking favorite records.'
+    s.license     = 'MIT'
+
+    s.rubyforge_project = 'acts_as_follower'
+
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+    s.require_paths = ['lib']
+
+    s.add_dependency 'activerecord', '>= 4.0'
+
+    s.add_development_dependency 'sqlite3', '~> 1'
+    s.add_development_dependency 'shoulda_create', '~> 0'
+    s.add_development_dependency 'shoulda', '~> 3'
+    s.add_development_dependency 'factory_girl', '~> 4'
+    s.add_development_dependency 'rails', '>= 4.0'
+end

data/init.rb

@@ -0,0 +1 @@
+require 'acts_as_favoritor'

data/lib/acts_as_favoritor.rb

@@ -0,0 +1,35 @@
+require 'acts_as_favoritor/version'
+
+module ActsAsFavoritor
+
+    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'
+
+    def self.setup
+        @configuration ||= Configuration.new
+        yield @configuration if block_given?
+    end
+
+    def self.method_missing method_name, *args, &block
+        if method_name == :custom_parent_classes=
+            ActiveSupport::Deprecation.warn 'Setting custom parent classes is deprecated and will be removed in future versions.'
+        end
+        @configuration.respond_to?(method_name) ?
+        @configuration.send(method_name, *args, &block) : super
+    end
+
+    class Configuration
+        attr_accessor :custom_parent_classes
+
+        def initialize
+            @custom_parent_classes = []
+        end
+    end
+
+    setup
+
+    require 'favoritor/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+    
+end

data/lib/acts_as_favoritor/favoritable.rb

@@ -0,0 +1,115 @@
+module ActsAsFavoritor #:nodoc:
+    module Favoritable
+
+        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
+            end
+        end
+
+        module InstanceMethods
+
+            # Returns the number of favoritors a record has.
+            def favoritors_count
+                self.favorited.unblocked.count
+            end
+
+            # Returns the favoritors by a given type
+            def favoritors_by_type favoritor_type, options = {}
+                favorites = favoritor_type.constantize.
+                joins(:favorites).
+                where('favorites.blocked': false,
+                'favorites.followable_id': self.id,
+                'favorites.followable_type': parent_class_name(self),
+                'favorites.follower_type': favoritor_type)
+                if options.has_key? :limit
+                    favorites = favorites.limit options[:limit]
+                end
+                if options.has_key? :includes
+                    favorites = favorites.includes options[:includes]
+                end
+
+                favorites
+            end
+
+            def favoritors_by_type_count favoritor_type
+                self.favorited.unblocked.for_favoritor_type(favoritor_type).count
+            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
+                else
+                    super
+                end
+            end
+
+            def respond_to? m, include_private = false
+                super || m.to_s[/count_(.+)_favoritors/] || m.to_s[/(.+)_favoritors/]
+            end
+
+            def blocked_favoritors_count
+                self.favorited.blocked.count
+            end
+
+            # Returns the favorited records scoped
+            def favoritors_scoped
+                self.favorited.includes :favoritor
+            end
+
+            def favoritors options = {}
+                favoritors_scope = favoritors_scoped.unblocked
+                favoritors_scope = apply_options_to_scope favoritors_scope, options
+                favoritors_scope.to_a.collect{ |f| f.favoritor }
+            end
+
+            def blocks options = {}
+                blocked_favoritors_scope = favoritors_scoped.blocked
+                blocked_favoritors_scope = apply_options_to_scope blocked_favoritors_scope, options
+                blocked_favoritors_scope.to_a.collect{ |f| f.favoritor }
+            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
+                self.favorited.unblocked.for_favoritor(favoritor).first.present?
+            end
+
+            def block favoritor
+                get_favorite_for(favoritor) ? block_existing_favorite(favoritor) : block_future_favorite(favoritor)
+            end
+
+            def unblock favoritor
+                get_favorite_for(favoritor).try(:delete)
+            end
+
+            def get_favorite_for favoritor
+                self.favorited.for_favoritor(favoritor).first
+            end
+
+            private
+
+            def block_future_favorite favoritor
+                Favorite.create favoritable: self, favoritor: favoritor, blocked: true
+            end
+
+            def block_existing_favorite favoritor
+                get_favorite_for(favoritor).block!
+            end
+
+        end
+
+    end
+end

data/lib/acts_as_favoritor/favorite_scopes.rb

@@ -0,0 +1,45 @@
+module ActsAsFavoritor #:nodoc:
+    module FavoriteScopes
+
+        # returns favorite records where favoritor is the record passed in.
+        def for_favoritor favoritor
+            where favoritor_id: favoritor.id, favoritor_type: parent_class_name(favoritor)
+        end
+
+        # returns favorite records where favoritable is the record passed in.
+        def for_favoritable favoritable
+            where favoritable_id: favoritable.id, favoritable_type: parent_class_name(favoritable)
+        end
+
+        # returns favorite records where favoritor_type is the record passed in.
+        def for_favoritor_type favoritor_type
+            where favoritor_type: favoritor_type
+        end
+
+        # returns favorite records where favoritable_type is the record passed in.
+        def for_favoritable_type favoritable_type
+            where favoritable_type: favoritable_type
+        end
+
+        # returns favorite records from past 2 weeks with default parameter.
+        def recent from
+            where ['created_at > ?', (from || 2.weeks.ago).to_s(:db)]
+        end
+
+        # returns favorite records in descending order.
+        def descending
+            order 'favorites.created_at desc'
+        end
+
+        # returns unblocked favorite records.
+        def unblocked
+            where blocked: false
+        end
+
+        # returns blocked favorite records.
+        def blocked
+            where blocked: true
+        end
+
+    end
+end

data/lib/acts_as_favoritor/favoritor.rb

@@ -0,0 +1,113 @@
+module ActsAsFavoritor #:nodoc:
+    module Follower
+
+        def self.included base
+            base.extend ClassMethods
+        end
+
+        module ClassMethods
+            def acts_as_favoritor
+                has_many :favorites, as: :favoritor, dependent: :destroy
+                include ActsAsFavoritor::Favoritor::InstanceMethods
+                include ActsAsFavoritor::FavoritorLib
+            end
+        end
+
+        module InstanceMethods
+
+            # Returns true if this instance is following the object passed as an argument.
+            def favorited? favoritable
+                0 < Favorite.unblocked.for_favoritor(self).for_favoritable(favoritable).count
+            end
+
+            # Returns the number of objects this instance is following.
+            def favorites_count
+                Favorite.unblocked.for_favoritor(self).count
+            end
+
+            # Creates a new favorite record for this instance to favorite the passed object.
+            # Does not allow duplicate records to be created.
+            def favorite favoritable
+                if self != favoritable
+                    params = {favoritable_id: favoritable.id, favoritable_type: parent_class_name(favoritable)}
+                    self.favorites.where(params).first_or_create!
+                end
+            end
+
+            # Deletes the favorite record if it exists.
+            def remove_favorite favoritable
+                if favorite = get_Favoritor favoritable
+                    favorite.destroy
+                end
+            end
+
+            # returns the favorite records to the current instance
+            def favorites_scoped
+                self.favorites.unblocked.includes :favoritable
+            end
+
+            # Returns the favorite records related to this instance by type.
+            def favorites_by_type favoritable_type, options={}
+                favorites_scope  = favorites_scoped.for_favoritable_type favoritable_type
+                favorites_scope = apply_options_to_scope favorites_scope, options
+            end
+
+            # Returns the favorite records related to this instance with the favoritable included.
+            def all_favorites options = {}
+                favorites_scope = favorites_scoped
+                favorites_scope = apply_options_to_scope favorites_scope, options
+            end
+
+            # Returns the actual records which this instance has favorited.
+            def all_favorited options = {}
+            all_favorites(options).collect{ |f| f.favoritable }
+            end
+
+            # Returns the actual records of a particular type which this record has fovarited.
+            def favorited_by_type favoritable_type, options = {}
+                favoritables = favoritable_type.constantize.
+                joins(:favorited).
+                where('favorites.blocked': false,
+                'favorites.favoritor_id': self.id,
+                'favorites.favoritor_type': parent_class_name(self),
+                'favorites.favoritable_type': favoritable_type)
+                if options.has_key? :limit
+                    favoritables = favoritables.limit options[:limit]
+                end
+                if options.has_key? :includes
+                    favoritables = favoritables.includes options[:includes]
+                end
+                favoritables
+            end
+
+            def favorited_by_type_count favoritable_type
+                favorites.unblocked.for_favoritable_type(favoritable_type).count
+            end
+
+            # Allows magic names on favorited_by_type
+            # e.g. favorited_users == favorited_by_type 'User'
+            # Allows magic names on favorited_by_type_count
+            # e.g. favorited_users_count == favorited_by_type_count 'User'
+            def method_missing m, *args
+                if m.to_s[/favorited_(.+)_count/]
+                    favorited_by_type_count $1.singularize.classify
+                elsif m.to_s[/favorited_(.+)/]
+                    favorited_by_type $1.singularize.classify
+                else
+                    super
+                end
+            end
+
+            def respond_to? m, include_private = false
+                super || m.to_s[/favorited_(.+)_count/] || m.to_s[/favorited_(.+)/]
+            end
+
+            # Returns a favorite record for the current instance and favoritable object.
+            def get_favorite favoritable
+                self.favorites.unblocked.for_favoritable(favoritable).first
+            end
+
+        end
+
+    end
+end