acts_as_favorite 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Josh B Martin
+
+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

@@ -0,0 +1,53 @@
+= ActsAsFavorite
+
+http://svn.webwideconsulting.com/svn/acts_as_favorite
+
+This plugin provides a simple way to track users favorites within the system using
+ActiveRecord models. 
+
+
+== Requirements
+  As we are not generating anything and there is no config, it is assumed in this version
+  that your user class is named "User", and you dont have an existing "Favorite" class.
+
+== Installation and Configuration
+
+1) Install as a plugin using script/plugin.
+2) Generate the Favorite model, migrations, and tests with
+    ./script/generate favorite_model Favorite
+3) rake migrate to create the required tables
+4) add <tt>acts_as_favorite_user</tt> to your User model
+5) add <tt>acts_as_favorite</tt> to any models which you want to provide to users for favorites.
+
+== The Specifics
+
+  Below are some specifics of using the plugin...
+
+=== Setting and Using favorites
+
+To Set:
+current_user.has_favorite(Blog.find(43))
+
+To Test(returns true/false):
+current_user.has_favorite?(Blog.find(99))
+current_user.has_favorite_venues?
+
+To Find:
+current_user.all_favorites  (all favorite referenced objects, blogs, etc)
+current_user.favorite_blogs  (metaprogramming references Blog entries only)
+Blog.find(43).favoriting_users (returns users which have the specified blog set as a favorite)
+
+=== Dynamic methods through the Identity mixin
+
+The Identity mixin provides some dynamic methods for accessing favorite based information. You
+can replace 'blahs' with any model class that acts_as_favorite.
+
+user.has_favorite_blahs?  --> returns true/false if the user has any favorites within the Blah class.
+user.favorite_blahs       --> returns an array of Blah's that are set as the users favorites.
+
+== License
+MIT License applies.
+
+== Authors
+Josh Martin
+

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_favorite plugin.'
+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_favorite plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsFavorite'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "acts_as_favorite"
+    gemspec.summary = "User fovorites for you web application"
+    gemspec.description = "This gem provides a simple way to track users favorites within the system using ActiveRecord models"
+    gemspec.email = "kossnocorp@gmail.com"
+    gemspec.homepage = "http://github.com/kossnocorp/acts_as_favorite"
+    gemspec.authors = ["Josh Martin"]
+    gemspec.version = "0.1"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/about.yml

@@ -0,0 +1,8 @@
+author: Josh Martin
+summary: Adds a flexible mechanism for tracking users favorites.
+description: Adds a flexible mechanism for tracking user favorites.
+homepage: http://localhost/
+plugin: http://svn.webwideconsulting.com/svn/acts_as_favorite/
+license: MIT
+version: 1.0
+rails_version: 1.0+

data/generators/favorite_model/USAGE

@@ -0,0 +1,20 @@
+Description:
+    The favorite_model generator creates a Role model for use with the ActsAsFavorite plugin.
+
+    The generator takes a model name as its argument, which at this time must be 'Favorite'.
+
+    The generator creates a Role model class in app/models, a test suite in
+    test/unit, test fixtures in test/fixtures/singular_name.yml, and a migration
+    in db/migrate.
+
+Example:
+    ./script/generate favorite_model Favorite
+
+    This will create a Role model:
+        Model:      app/models/favorite.rb
+        Test:       test/unit/favorite_test.rb
+        Fixtures:   test/fixtures/favorites.yml
+        Migration:  db/migrate/XXX_add_favorites.rb
+        
+    You should then run "rake migrate".
+

data/generators/favorite_model/favorite_model_generator.rb

@@ -0,0 +1,35 @@
+# Shamelessly derived from Rick Olsen's acts_as_attachment
+class FavoriteModelGenerator < Rails::Generator::NamedBase
+  default_options :skip_migration => false
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      # Model, test, and fixture directories.
+      m.directory File.join('app/models', class_path)
+      m.directory File.join('test/unit', class_path)
+      m.directory File.join('test/fixtures', class_path)
+
+      # Model class, unit test, and fixtures.
+      m.template 'model.rb',      File.join('app/models', class_path, "#{file_name}.rb")
+      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+      m.template 'fixtures.yml',  File.join('test/fixtures', class_path, "#{table_name}.yml")
+      
+      unless options[:skip_migration]
+        m.migration_template 'migration.rb', 'db/migrate', :assigns => {
+          :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+        }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+      end
+    end
+  end
+
+  protected
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--skip-migration", 
+             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+    end
+end

data/generators/favorite_model/templates/fixtures.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+another:
+  id: 2

data/generators/favorite_model/templates/migration.rb

@@ -0,0 +1,15 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %>, :force => true do |t|
+      t.column :user_id,            :integer
+      t.column :favorable_type,     :string, :limit => 30
+      t.column :favorable_id,       :integer
+      t.column :created_at,         :datetime
+      t.column :updated_at,         :datetime
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/generators/favorite_model/templates/model.rb

@@ -0,0 +1,5 @@
+# Defines named favorites for users that may be applied to objects in a polymorphic fashion.
+class <%= class_name %> < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :favorable, :polymorphic => true
+end

data/generators/favorite_model/templates/unit_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  fixtures :<%= table_name %>
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/acts_as_favorite'

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'README'))

data/lib/acts_as_favorite.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/identity'
+
+module ActsAsFavorite
+
+  module UserExtensions
+    def self.included( recipient )
+      recipient.extend( ClassMethods )
+    end
+
+    module ClassMethods
+      def acts_as_favorite_user
+        has_many :favorites
+        has_many :favorables, :through => :favorites
+        include ActsAsFavorite::UserExtensions::InstanceMethods
+        include ActsAsFavorite::Identity::UserExtensions::InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+
+      # Returns a polymorphic array of all user favorites
+      def all_favorites
+        self.favorites.map{|f| f.favorable }
+      end
+
+      # Returns trur/false if the provided object is a favorite of the users
+      def has_favorite?( favorite_obj )
+        favorite = get_favorite( favorite_obj )
+        favorite ? self.favorites.exists?( favorite.id ) : false
+      end
+
+      # Sets the object as a favorite of the users
+      def has_favorite( favorite_obj )
+        favorite = get_favorite( favorite_obj )
+        if favorite.nil?
+          favorite = Favorite.create( :user_id => self.id,
+                                      :favorable_type => favorite_obj.class.to_s,
+                                      :favorable_id   => favorite_obj.id )
+        end
+        favorite
+      end
+
+      # Removes an object from the users favorites
+      def has_no_favorite( favorite_obj )
+        favorite = get_favorite ( favorite_obj )
+
+        # ACA: The original plugin did not properly destroy the favorite.
+        # Instead, it just removed the element from the favorites list. If the
+        # favorites list was refetched from the DB, surprise! It came back!
+
+        if favorite
+          self.favorites.delete( favorite )
+          favorite_obj.favorites.delete( favorite )
+          favorite.destroy
+        end
+      end
+
+      private
+
+      # Returns a favorite
+      def get_favorite( favorite_obj )
+        # ACA: The original plugin did not incoorporate the user id. This
+        # meant that the has_many associations did not find favorites
+        # properly.
+        Favorite.find( :first,
+                       :conditions => [ 'user_id = ? AND favorable_type = ? AND favorable_id = ?',
+                                         self.id, favorite_obj.class.to_s, favorite_obj.id ] )
+      end
+    end
+  end
+
+
+  module ModelExtensions
+    def self.included( recipient )
+      recipient.extend( ClassMethods )
+    end
+
+    module ClassMethods
+      def acts_as_favorite
+        has_many :favorites, :as => :favorable
+        has_many :favoriting_users, :through => :favorites, :source => :user
+
+        # ACA: The original plugin included unnecessary repetitions of the
+        # instance method definitions as well as the below include.
+
+        include ActsAsFavorite::ModelExtensions::InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      def accepts_favorite?( user_obj )
+        user_obj.has_favorite?( self )
+      end
+
+      def accepts_favorite( user_obj )
+        user_obj.has_favorite( self )
+      end
+
+      def accepts_no_favorite( user_obj )
+        user_obj.has_no_favorite( self )
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send( :include,
+  ActsAsFavorite::UserExtensions,
+  ActsAsFavorite::ModelExtensions
+)

data/lib/identity.rb

@@ -0,0 +1,28 @@
+module ActsAsFavorite
+  module Identity
+  
+    module UserExtensions
+      module InstanceMethods
+
+        def method_missing( method_sym, *args )
+          if method_sym.to_s =~ Regexp.new("^favorite_(\\w+)")
+            favorite_class = ($1).singularize.classify.constantize
+            favorite_class.find(:all, :include => :favorites,
+                                :conditions => ['favorites.user_id = ? AND favorites.favorable_type = ?', 
+                                                id, favorite_class.to_s ] )
+          elsif method_sym.to_s =~ Regexp.new("^has_favorite_(\\w+)\\?")
+            favorite_class = ($1).singularize.classify.constantize
+            Favorite.count( :include => :user, :conditions => [ 'favorites.user_id = ? AND favorites.favorable_type = ?', 
+                                                                id, favorite_class.to_s ] ) != 0
+          else
+            super
+          end
+        rescue
+          super
+        end
+        
+      end
+    end
+    
+  end
+end

data/tasks/acts_as_favorite_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_favorite do
+#   # Task goes here
+# end

data/test/acts_as_favorite_test.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class User < ActiveRecord::Base
+  acts_as_favorite_user
+end
+
+class Favorite < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :favorable, :polymorphic => true
+end
+
+class Book < ActiveRecord::Base
+  acts_as_favorite
+end
+
+class Drink < ActiveRecord::Base
+  acts_as_favorite
+end
+
+class ActsAsFavoriteTest < Test::Unit::TestCase
+  fixtures :users, :books, :drinks, :favorites
+  
+  def test_user_should_have_favorites
+    assert users(:josh).has_favorites?
+  end
+
+  def test_should_create_favorite
+    assert_difference users(:james).favorites, :count do
+      users(:james).has_favorite books(:agile)
+    end
+  end
+
+  def test_dynamic_counter_should_return_true
+    assert users(:josh).has_favorite_books?
+  end
+
+  def test_should_return_false_with_no_favorite_books
+    assert_equal users(:george).has_favorite_books?, false
+  end
+
+  def test_should_add_items_to_favorites
+    assert_difference Favorite, :count do
+      users(:james).has_favorite drinks(:wine)
+      assert users(:james).has_favorite?(drinks(:wine))
+    end
+  end
+
+  def test_should_remove_from_favorites
+    assert_difference users(:josh).favorites, :count, -1 do
+      users(:josh).has_no_favorite drinks(:beer)
+    end
+  end
+
+  def test_should_return_users_with_specified_favorite
+    assert books(:ruby).favorite_users.include?(users(:josh))
+  end
+
+  def test_should_add_and_remove_favorites
+
+    assert users(:george).favorites.empty?
+
+    assert_difference users(:george).favorites, :count, 3 do
+      users(:george).has_favorite books(:agile)
+      users(:george).has_favorite books(:ruby)
+      users(:george).has_favorite books(:rails)
+    end
+    assert_equal users(:george).favorites.size, 3
+    assert users(:george).favorite_books.size, 3
+
+    assert_difference users(:george).favorites, :count, -2 do
+      users(:george).has_no_favorite books(:agile)
+      users(:george).has_no_favorite books(:ruby)
+    end
+    assert_equal users(:george).favorites.size, 1
+    assert users(:george).favorite_books.size, 1
+
+  end
+
+end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: acts_as_favorite_plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: acts_as_favorite_plugin.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: acts_as_favorite_plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: acts_as_favorite_plugin_test

data/test/fixtures/books.yml

@@ -0,0 +1,11 @@
+ruby:
+  id: 1
+  title: Programming Ruby
+
+agile:
+  id: 2
+  title: Agile Web Development with Rails
+
+rails:
+  id: 3
+  title: Ruby for Rails

data/test/fixtures/drinks.yml

@@ -0,0 +1,15 @@
+beer:
+  id: 1
+  title: Beer
+
+wine:
+  id: 2
+  title: Wine
+
+cola:
+  id: 3
+  title: Cola
+
+coffee:
+  id: 4
+  title: Coffee

data/test/fixtures/favorites.yml

@@ -0,0 +1,23 @@
+josh_ruby:
+  id: 1
+  user_id: 1
+  favorable_type: Book
+  favorable_id: 1
+
+josh_agile:
+  id: 2
+  user_id: 1
+  favorable_type: Book
+  favorable_id: 2
+
+josh_rails:
+  id: 3
+  user_id: 1
+  favorable_type: Book
+  favorable_id: 3
+
+josh_beer:
+  id: 4
+  user_id : 1
+  favorable_type: Drink
+  favorable_id: 1

data/test/fixtures/users.yml

@@ -0,0 +1,15 @@
+josh:
+  id: 1
+  name: Josh
+
+bob:
+  id: 2
+  name: Bob
+
+james:
+  id: 3
+  name: James
+
+george:
+  id: 4
+  name: George

data/test/schema.rb

@@ -0,0 +1,24 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string, :limit => 50
+  end
+
+  create_table :favorites, :force => true do |t|
+    t.column :user_id,          :integer
+    t.column :favorable_id,     :integer
+    t.column :favorable_type,   :string, :limit => 30
+    t.column :created_at,       :datetime
+    t.column :updated_at,       :datetime
+  end
+
+  create_table :books, :force => true do |t|
+    t.column :title,            :string, :limit => 30
+  end
+  
+  create_table :drinks, :force => true do |t|
+    t.column :title,            :string, :limit => 30
+  end
+
+end
+  

data/test/test_helper.rb

@@ -0,0 +1,44 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'rubygems'
+require 'active_support/breakpoint'
+require 'active_record/fixtures'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite'])
+
+load(File.dirname(__FILE__) + "/schema.rb")
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+  def assert_difference(object, method = nil, difference = 1)
+    initial_value = object.send(method)
+    yield
+    assert_equal initial_value + difference, object.send(method), "#{object}##{method}"
+  end
+
+  def assert_no_difference(object, method, &block)
+    assert_difference object, method, 0, &block
+  end
+
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_favorite
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Josh Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-08 00:00:00 +06:00
+default_executable: 
+dependencies: []
+
+description: This gem provides a simple way to track users favorites within the system using ActiveRecord models
+email: kossnocorp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- about.yml
+- generators/favorite_model/USAGE
+- generators/favorite_model/favorite_model_generator.rb
+- generators/favorite_model/templates/fixtures.yml
+- generators/favorite_model/templates/migration.rb
+- generators/favorite_model/templates/model.rb
+- generators/favorite_model/templates/unit_test.rb
+- init.rb
+- install.rb
+- lib/acts_as_favorite.rb
+- lib/identity.rb
+- tasks/acts_as_favorite_tasks.rake
+- test/acts_as_favorite_test.rb
+- test/database.yml
+- test/fixtures/books.yml
+- test/fixtures/drinks.yml
+- test/fixtures/favorites.yml
+- test/fixtures/users.yml
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/kossnocorp/acts_as_favorite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: User fovorites for you web application
+test_files: 
+- test/acts_as_favorite_test.rb
+- test/schema.rb
+- test/test_helper.rb