can_be_flagged 0.0.2

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails-brochure.gemspec
+gemspec
+
+group :test do
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    can_be_flagged (0.0.2)
+      activerecord (>= 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.7)
+    arel (2.0.10)
+    builder (2.1.2)
+    i18n (0.5.0)
+    sqlite3 (1.3.3)
+    tzinfo (0.3.27)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  can_be_flagged!
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Dan Hixon
+
+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.rdoc

@@ -0,0 +1,84 @@
+Can Be Flagged
+=================
+
+Allows for flags to be added to multiple and different models.
+
+== Resources
+
+Install
+
+* To install as a gem (recommended):
+** gem install can_be_flagged or
+** Just add "gem 'can_be_flagged'" to your Gemfile and "bundle install"
+ 
+Generate your flag model:
+
+** Rails 3: rails g flags
+
+Then migrate your database:
+
+** rake db:migrate
+
+== Usage
+ 
+ * Mark your ActiveRecord model can_be_flagged.
+ 
+ class Post < ActiveRecord::Base
+ 	can_be_flagged
+ end
+ 
+ * Add a flag to a model instance
+ 
+ flaggable = Post.create(:text => "Don't be offended by this.")
+ flaggable.flags.create(:comment => "I am offended by that!")
+
+ * I like to add a counter cache column to my flaggable types:
+
+ add_column :posts, :flags_count, :integer
+
+ class Flag < ActiveRecord::Base
+   belongs_to :flaggable, :polymorphic=>true, :counter_cache=>true
+ end
+
+ * You can have different types of flags
+
+ class Article
+   can_be_flagged :offensive, :spam
+ end
+ 
+ * This gives you methods like this:
+ @article.offensive_flags.create(:comment => "gross!")
+ @article.spam_flags.create(:comment => "Don't sell your pharmaceuticals on this site!")
+ Aricle.find_spam_flags_for(@article)
+
+ * You can also add a callback
+   
+ class Article
+   can_be_flagged :after_add => :flagged
+
+   def flagged
+     # send an email
+     # maybe delete this article if there are too many flags
+   end
+
+ end
+ 
+ * In fact you can pass any options that are accepted by has_many:
+ 
+ class Article
+   can_be_flagged :dependent=>:nullify
+ end
+
+== Credits
+
+Juxie - The code for this plugin is heavily influenced by Acts As Commentable.
+
+Bacon Bear? - Frankenstien'd some features from acts_as_flaggable
+
+== Contributors
+
+Dan Hixon
+
+== License
+
+Flag This is Copyright © 2010-2011 Dan Hixon. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/can_be_flagged.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name = %q{can_be_flagged}
+  s.version     = FlagThis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dan Hixon"]
+  #s.autorequire = %q{can_be_flagged}
+  s.date = %q{2011-05-23}
+  s.summary = %q{Gem that provides flagging functionality for active record objects}
+  s.description = %q{Gem that provides flagging functionality for active record objects, just add can_be_flagged to your models.}
+  s.email = %q{danhixon@gmail.com}
+  s.homepage    = "http://github.com/danhixon/can_be_flagged"
+  
+  s.add_dependency('activerecord', '>= 3.0.0')
+
+  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"]
+end

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails', 'init')

data/install.rb

@@ -0,0 +1,2 @@
+puts "To create the flag model please run:"
+puts "rails g flag"

data/lib/can_be_flagged.rb

@@ -0,0 +1,2 @@
+require 'can_be_flagged_methods'
+require 'flag_methods'

data/lib/can_be_flagged_methods.rb

@@ -0,0 +1,59 @@
+require 'active_record'
+module ActiveRecord
+  module FlagThis #:nodoc:
+
+    def self.included(base)
+      base.extend ClassMethods  
+    end
+    
+    module ClassMethods
+      def can_be_flagged(options = {})
+        roles = options.delete(:roles)
+        flag_roles = roles.to_a.compact.map(&:to_sym)
+        write_inheritable_attribute(:flag_types, (flag_roles.blank? ? [:abuse] : flag_roles))
+        class_inheritable_reader(:flag_types)
+
+        #options = ((args.blank? or args[0].blank?) ? {} : args[0])
+
+        if !flag_roles.blank?
+          flag_roles.each do |role|
+            has_many "#{role.to_s}_flags".to_sym,
+              { :class_name => "Flag",
+                :as => :flaggable,
+                :dependent => :destroy,
+                :conditions => ["role = ?", role.to_s],
+                :before_add => Proc.new { |x, c| c.role = role.to_s }}.merge(options)
+          end
+        else
+          has_many :flags, {:as => :flaggable, :dependent => :destroy}.merge(options)
+        end
+        
+        flag_types.each do |role|
+          method_name = (role == :abuse ? "flags" : "#{role.to_s}_flags").to_s
+          class_eval %{
+            def self.find_#{method_name}_for(obj)
+              flaggable = self.base_class.name
+              Flag.find_flags_for_flaggable(flaggable, obj.id, "#{role.to_s}")
+            end
+
+            def self.find_#{method_name}_by_user(user) 
+              flaggable = self.base_class.name
+              Flag.where(["user_id = ? and flaggable_type = ? and role = ?", user.id, flaggable, "#{role.to_s}"]).order("created_at DESC")
+            end
+
+            def #{method_name}_ordered_by_submitted
+              Flag.find_flags_for_flaggable(self.class.name, id, "#{role.to_s}")
+            end
+
+            def add_#{method_name.singularize}(flag)
+              flag.role = "#{role.to_s}"
+              #{method_name} << flag
+            end
+          }
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActiveRecord::FlagThis)

data/lib/flag_methods.rb

@@ -0,0 +1,41 @@
+module FlagThis
+  # including this module into your Flag model will give you finders and named scopes
+  # useful for working with Flags.
+  module Flag
+
+    def self.included(flag_model)
+      flag_model.extend ClassMethods
+      flag_model.scope :in_order, flag_model.order('created_at ASC')
+      flag_model.scope :recent,   flag_model.order('created_at DESC')
+    end
+
+    def is_flag_type?(type)
+      type.to_s == role.singularize.to_s
+    end
+   
+    module ClassMethods
+      def this_is_a_flag
+        #after_create :callback_flaggable
+        
+      end
+      # Helper class method to lookup all flags assigned
+      # to all flaggable types for a given user.
+      def find_flags_by_user(user, role = "abuse")
+        where(["user_id = ? and role = ?", user.id, role]).order("created_at DESC")
+      end
+
+      # Helper class method to look up all flags for 
+      # flaggable class name and flaggable id.
+      def find_flags_for_flaggable(flaggable_str, flaggable_id, role = "abuse")
+        where(["flaggable_type = ? and flaggable_id = ? and role = ?", flaggable_str, flaggable_id, role]).order("created_at DESC")
+      end
+
+      # Helper class method to look up a flaggable object
+      # given the flaggable class name and id 
+      def find_flaggable(flaggable_str, flaggable_id)
+        model = flaggable_str.constantize
+        model.respond_to?(:find_flags_for) ? model.find(flaggable_id) : nil
+      end
+    end
+  end
+end

data/lib/generators/flags/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Copies flag.rb to app/models/.
+    Copies create_flags.rb to db/migrate
+
+Examples:
+    `rails generate flags`

data/lib/generators/flags/flags_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators/migration'
+
+class FlagsGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  def self.source_root
+    @_can_be_flagged_source_root ||= File.expand_path("../templates", __FILE__)
+  end
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_model_file
+    template "flag.rb", "app/models/flag.rb"
+    migration_template "create_flags.rb", "db/migrate/create_flags.rb"
+  end
+end

data/lib/generators/flags/templates/create_flags.rb

@@ -0,0 +1,19 @@
+class CreateFlags < ActiveRecord::Migration
+  def self.up
+    create_table :flags do |t|
+      t.text :comment
+      t.references :flaggable, :polymorphic => true
+      t.references :user
+      # other roles could be spam, inappropriate, etc.
+      t.string :role, :default => "abuse"
+      t.timestamps
+    end
+
+    add_index :flags, [:flaggable_type, :flaggable_id]
+    add_index :flags, :user_id
+  end
+
+  def self.down
+    drop_table :flags
+  end
+end

data/lib/generators/flags/templates/flag.rb

@@ -0,0 +1,9 @@
+class Flag < ActiveRecord::Base
+  include FlagThis::Flag
+  this_is_a_flag
+  
+  belongs_to :flaggable, :polymorphic => true
+  # Flags belong to a user
+  belongs_to :user
+  
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module FlagThis
+  VERSION = "0.0.2"
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'can_be_flagged')
+

data/tasks/flag_this_tasks.rake

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

data/test/can_be_flagged_test.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+require 'logger'
+require File.expand_path(File.dirname(__FILE__) + '/../rails/init')
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+class FlagThisTest < Test::Unit::TestCase
+
+  def setup_flags
+    require File.expand_path(File.dirname(__FILE__) + '/../lib/generators/flags/templates/create_flags') 
+    CreateFlags.up
+    load(File.expand_path(File.dirname(__FILE__) + '/../lib/generators/flags/templates/flag.rb'))
+  end
+
+  def setup_test_models
+    load(File.expand_path(File.dirname(__FILE__) + '/schema.rb'))
+    load(File.expand_path(File.dirname(__FILE__) + '/models.rb'))
+  end
+
+  def setup
+    setup_flags
+    setup_test_models
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+
+  def test_create_flag
+    post = Post.create(:text => "Awesome post !")
+    assert_not_nil post.flags.create().id
+
+    reply = Reply.create(:text => "I want you to buy some enlarging products.")
+    assert_not_nil reply.spam_flags.create(:comment => "this is definately spam.").id
+    assert_not_nil reply.offensive_flags.create(:comment => "this is offensive to me.").id
+    assert_raise NoMethodError do
+      reply.flags.create(:comment=>"unspecific flag")
+    end
+  end
+
+  def test_fetch_flags
+    post = Post.create(:text => "Awesome post !")
+    post.flags.create(:comment => "This is the first flag.")
+    flaggable = Post.find(1)
+    assert_equal 1, flaggable.flags.length
+    assert_equal "This is the first flag.", flaggable.flags.first.comment
+
+    reply = Reply.create(:text => "You should check out my website instead!")
+    offensive_flag = reply.offensive_flags.create(:comment => "I am so offended!")
+    assert_equal [offensive_flag], reply.offensive_flags
+    spam_flag = reply.spam_flags.create(:comment => "I can't stand the spam!")
+    assert_equal [spam_flag], reply.spam_flags
+  end
+
+  def test_find_flags_for_flaggable
+    post = Post.create(:text => "Awesome Post Part Deux.")
+    flag = post.flags.create(:comment => "This is the first flag.")
+    assert_equal [flag], Flag.find_flags_for_flaggable(post.class.name, post.id)
+  end
+
+  def test_find_flaggable
+    post = Post.create(:text => "Awesome post Parte Two")
+    flag = post.flags.create(:comment => "This is the first flag.")
+    assert_equal post, Flag.find_flaggable(post.class.name, post.id) 
+  end
+
+  def test_find_flags_for
+    post = Post.create(:text => "Awesome post !")
+    flag = post.flags.create(:comment => "This is the first flag.")
+    assert_equal [flag], Post.find_flags_for(post)
+
+    reply = Reply.create(:text => "Shimmering Splendorous Sausage")
+    offensive_flag = reply.offensive_flags.create(:comment => "gross!")
+    assert_equal [offensive_flag], Reply.find_offensive_flags_for(reply)
+
+    spam_flag = reply.spam_flags.create(:comment => "I'm sick of sausage ads")
+    assert_equal [spam_flag], Reply.find_spam_flags_for(reply)
+  end
+
+  def test_find_flags_by_user
+    user = User.create(:name => "Mike")
+    user2 = User.create(:name => "Fake") 
+    post = Post.create(:text => "Awesome post!")
+    flag = post.flags.create(:comment => "This is the first flag.", :user => user)
+    assert_equal true, Post.find_flags_by_user(user).include?(flag)
+    assert_equal false, Post.find_flags_by_user(user2).include?(flag)
+    
+    reply = Reply.create(:text => "What would thousands of new visitors mean for your business?")
+    spam_flag = reply.spam_flags.create(:comment => "Stop selling stuff in replies!", :user => user)
+    assert_equal [spam_flag], Reply.find_spam_flags_by_user(user)
+
+    offensive_flag = reply.offensive_flags.create(:comment => "Offended!!", :user => user)
+    assert_equal [offensive_flag], Reply.find_offensive_flags_by_user(user)
+  end
+
+  def test_add_flag
+    post = Post.create(:text => "Super Post of a Post")
+    flag = Flag.new(:comment => 'I am not happy about this.')
+    post.add_flag(flag)
+    assert_equal [flag], post.flags
+
+    reply = Reply.create(:text => "I am so eager to try something else right now.")
+    spam_flag = Flag.new(:comment => 'super spammy')
+    reply.add_spam_flag(spam_flag)
+    assert_equal [spam_flag], reply.spam_flags
+
+    offensive_flag = Flag.new(:comment => 'super offensive')
+    reply.add_offensive_flag(offensive_flag)
+    assert_equal [offensive_flag], reply.offensive_flags
+  end
+
+  def test_is_flag_type
+    post = Post.create(:text => "Terrible Post")
+    flag = Flag.new(:comment => 'Super flag')
+    post.add_flag(flag)
+    assert_equal true, flag.is_flag_type?(:abuse)
+
+    reply = Reply.create(:text => "Happy people live longer")
+    
+    flag = Flag.new(:comment => "That is unfounded and thereby offensive.")
+    reply.add_offensive_flag(flag)
+    assert_equal true, flag.is_flag_type?(:offensive)
+
+    spam = Flag.new(:comment => 'Stop trying to sell happiness. It not work.')
+    reply.add_spam_flag(spam)
+    assert_equal true, spam.is_flag_type?(:spam)
+    assert_equal false, spam.is_flag_type?(:abuse)
+
+  end
+  
+  def test_after_flagged_callback
+    post = Post.create(:text => "Terrible Post")
+    post.flags.create(:comment => 'I wish to report this post.')
+    post.reload
+    assert_equal 1, post.flags_count
+    
+  end
+  
+end

data/test/models.rb

@@ -0,0 +1,18 @@
+class Post < ActiveRecord::Base
+  can_be_flagged :after_add=>:flagged
+
+  private
+  def flagged(flag)
+    self.flags_count += 1
+    self.save
+  end
+  
+end
+
+class User < ActiveRecord::Base
+  
+end
+
+class Reply < ActiveRecord::Base
+  can_be_flagged :roles => [:offensive, :spam]
+end

data/test/schema.rb

@@ -0,0 +1,17 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :posts do |t|
+    t.text :text
+    t.datetime
+    t.text :type
+    t.integer :flags_count, :default => 0
+  end
+
+  create_table :users do |u|
+    u.string :name
+  end
+
+  create_table :replies do |w|
+    w.string :text
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: can_be_flagged
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Dan Hixon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: Gem that provides flagging functionality for active record objects, just add can_be_flagged to your models.
+email: danhixon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- can_be_flagged.gemspec
+- init.rb
+- install.rb
+- lib/can_be_flagged.rb
+- lib/can_be_flagged_methods.rb
+- lib/flag_methods.rb
+- lib/generators/flags/USAGE
+- lib/generators/flags/flags_generator.rb
+- lib/generators/flags/templates/create_flags.rb
+- lib/generators/flags/templates/flag.rb
+- lib/version.rb
+- rails/init.rb
+- tasks/flag_this_tasks.rake
+- test/can_be_flagged_test.rb
+- test/models.rb
+- test/schema.rb
+has_rdoc: true
+homepage: http://github.com/danhixon/can_be_flagged
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Gem that provides flagging functionality for active record objects
+test_files: 
+- test/can_be_flagged_test.rb
+- test/models.rb
+- test/schema.rb