can_flag 1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Cosmin Radoi
+
+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,62 @@
+Can Flag
+=================
+Strongly inspired by acts_as_flaggable.
+Intended to allow your users to flag content as inappropriate, and set up some ways for you 
+to deal with the content.
+
+== Resources
+
+Install
+
+1. Download the tarball from github, or, clone the repository and symlink it into your application.
+   Yes, I'm serious.
+  
+2. $ script/generate can_flag flags
+
+   This will create the following files:
+     app/controllers/flags_controller.rb
+     spec/helpers/flags_controller_spec.rb
+     app/helpers/flags_helper
+     db/migrate/flags_migration.rb
+
+3. Modify any content model with
+  
+   class Article < ActiveRecord::Base
+     can_be_flagged
+   end
+   
+   You can also add a callback
+   
+   class Article
+     can_be_flagged
+     def after_flagged
+       # send an email
+       # delete this post
+       # suspend the owner of the post if the flags.size > 3
+       # suspend the owner of the post if their total flags count > 5
+     end
+   end
+
+4. Modify your user model with
+ 
+   class User < ActiveRecord::Base
+     can_flag     
+   end
+
+5. Usage
+
+   article = Article.find(4)
+   current_user.flags.create :flaggable => article
+
+ 
+
+ * When a flag is added via add_flag, flagged(flag, flag_count) is called
+   on the flaggable model.  This allows the model to perform certain
+   operations if the number of flags reaches a certain point.  For example,
+   you may want to mark a Post as deleted if a Post receives too many "spam"
+   flags
+ 
+ * Each flag reference flaggable object
+ 
+ model = Model.find(1)
+ model.flags.get(0).commtable == model

data/lib/can_flag.rb

@@ -0,0 +1,140 @@
+# CanFlag
+module Caboose
+  module Can 
+    module Flag
+      def self.included(base)
+        base.extend ClassMethods  
+        if defined?(::ActiveSupport::Callbacks)
+          base.define_callbacks :after_flagged
+        end
+      end
+
+      module ClassMethods
+        # Call can_be_flagged from your content model, or from anything
+        # you want to flag.
+        def can_be_flagged(opts={})
+          has_many :flags, :as => :flaggable, :dependent => :destroy
+          validates_associated :flags, :message => 'failed to validate'
+          include Caboose::Can::Flag::InstanceMethods
+          extend  Caboose::Can::Flag::SingletonMethods
+          cattr_accessor :reasons
+          self.reasons = opts[:reasons] || [:inappropriate]
+          (::Flag.flaggable_models ||= []) << self
+        end
+        
+        # Call can_flag from your user model, or anything that can own a flagging.
+        # That's a paddlin!
+        # Limitation for now: you should only allow one model to own flags.
+        # This is ridiculously easy to make polymorphic, but no ponies yet.
+        def can_flag
+          # has_many :flaggables, :foreign_key => "user_id"
+          # User created these flags
+          has_many :flags, :foreign_key => "user_id", :order => "id desc"
+          
+          # User was responsible for creating this filth
+          has_many :flaggings, :foreign_key => "flaggable_user_id", :class_name => "Flag"
+          include CanFlagInstanceMethods
+          
+          # Associate the flag back here
+          # Flag.belongs_to :user
+          # Flag.belongs_to :owner, :foreign_key => flaggable_user_id
+          ::Flag.class_eval "belongs_to :#{name.underscore}, :foreign_key => :user_id; 
+            belongs_to :owner, :foreign_key => :flaggable_user_id, :class_name => '#{name}'"
+        end
+      end
+      
+      # This module contains class methods
+      module SingletonMethods
+      #  # Helper method to lookup for flags for a given object.
+      #  # This method is equivalent to obj.flags.
+      #  def find_flags_for(obj)
+      #    flaggable = ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s
+      #   
+      #    Flag.find(:all,
+      #      :conditions => ["flaggable_id = ? and flaggable_type = ?", obj.id, flaggable],
+      #      :order => "created_at DESC"
+      #    )
+      #  end
+      #  
+      #  # Helper class method to lookup flags for
+      #  # the mixin flaggable type written by a given user.  
+      #  # This method is NOT equivalent to Flag.find_flags_for_user
+      #  def find_flags_by_user(user) 
+      #    flaggable = ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s
+      #    
+      #    Flag.find(:all,
+      #      :conditions => ["user_id = ? and flaggable_type = ?", user.id, flaggable],
+      #      :order => "created_at DESC"
+      #    )
+      #  end
+      end
+      
+      module CanFlagInstanceMethods
+        def flagged?(content)
+          logger.warn "Looking for flags with #{content.inspect} #{content.class.name}"
+          ::Flag.find(:first,
+            :conditions => { :flaggable_type => content.class.name, :flaggable_id => content[:id] })
+        end
+        
+        def flagged_by?(content, user)
+          ::Flag.find(:first,
+            :conditions => { :flaggable_type => content.class.name, :flaggable_id => content[:id], :flaggable_user_id => user.id })
+        end
+      end
+      
+      ## This module contains instance methods
+      module InstanceMethods
+        
+        def flagged?
+          flags.size > 0
+        end
+        
+        # Flag content with a mass-updater; sets the flagging user.
+        # article.update_attributes { 'flagged' => current_user.id }
+        def flagged=(by_who)
+          flags.build :user_id => by_who
+        end
+      #  
+      #  # Check to see if the passed in user has flagged this object before.
+      #  # Optionally you can test to see if this user has flagged this object
+      #  # with a specific flag
+      #  def user_has_flagged?(user, flag = nil)
+      #    conditions = flag.nil? ? {} : {:flag => flag}
+      #    conditions.merge!({:user_id => user.id})
+      #    return flags.count(:conditions =>conditions) > 0
+      #  end
+      #  
+      #  # Count the number of flags tha have this specific
+      #  # flag set
+      #  def count_flags_with_flag(flag)
+      #    flags.count(:conditions => ["flag = ?", flag])
+      #  end
+      #  
+      #  # Add a flag.  You can either pass in an
+      #  # instance of a flag or pass in a hash of attributes to be used to 
+      #  # instantiate a new flag object
+      #  def add_flag(options)
+      #    if options.kind_of?(Hash)
+      #      flag = Flag.new(options)
+      #    elsif options.kind_of?(Flag)
+      #      flag = options
+      #    else
+      #      raise "Invalid options"
+      #    end
+      #    
+      #    flags << flag
+      #    
+      #    # Call flagged to allow model to handle the act of being
+      #    # flagged
+      #    flagged(flag.flag, count_flags_with_flag(flag.flag))
+      #  end
+      #  
+      #  # Meant to be overriden
+      #  protected
+      #  def flagged(flag, flag_count)
+      #  end
+      end
+      
+    end
+  end
+end

data/lib/can_flag/rails_commands.rb

@@ -0,0 +1,30 @@
+# Stolen from Technoweenie's restful_authentication
+Rails::Generator::Commands::Create.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    sentinel = 'ActionController::Routing::Routes.draw do |map|'
+
+    logger.route "map.resource #{resource_list}"
+    unless options[:pretend]
+      gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+        "#{match}\n  map.resource #{resource_list}\n"
+      end
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    look_for = "\n  map.resource #{resource_list}\n"
+    logger.route "map.resource #{resource_list}"
+    gsub_file 'config/routes.rb', /(#{look_for})/mi, ''
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def route_resource(*resources)
+    resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+    logger.route "map.resource #{resource_list}"
+  end
+end

data/lib/flag.rb

@@ -0,0 +1,65 @@
+class Flag < ActiveRecord::Base
+  # serialize :flag, Symbol
+  belongs_to :flaggable, :polymorphic => true
+
+  # This will contain the names of all models that can_be_flagged
+  cattr_accessor :flaggable_models
+  
+  # This line is dynamically generated when you call "can_flag" in your user/account model.
+  # It assumes that content is owned by the same class as flaggers.
+  # belongs_to :owner, :through => :flaggable, :class_name => ??
+
+  # This is set dynamically in the plugin.
+  # define "can_flag" in your user/account model.
+  # belongs_to :user
+
+  validates_presence_of :flaggable_id, :flaggable_type
+
+  # requires all your content to have a user_id.  if not, then
+  validates_presence_of :flaggable_user_id, :on => :create, 
+    # :message => "error - your content must be owned by a user.",
+    :if => Proc.new { |c| c.flaggable and c.flaggable.user_id }
+
+  # A user can flag a specific flaggable with a specific flag once
+  validates_uniqueness_of :user_id, :scope => [:flaggable_id, :flaggable_type]
+
+  after_create :callback_flaggable
+  # Pings the 'after_flagged' callback in the content model, if it exists.
+  def callback_flaggable
+    flaggable.callback :after_flagged
+  end
+  
+  before_validation_on_create :set_owner_id
+  def set_owner_id
+    self.flaggable_user_id = flaggable.user_id
+  end
+  
+  validates_each :reason do |record,attr,value|
+    record.errors.add(attr, "don't include '#{value}' as an option") if value and !record.flaggable.reasons.include?(value.to_sym)
+  end
+
+  # UNTESTED
+  # # Helper class method to lookup all flags assigned
+  # # to all flaggable types for a given user.
+  # def self.find_flags_by_user(user)
+  #   find(:all,
+  #     :conditions => ["user_id = ?", user.id],
+  #     :order => "created_at DESC"
+  #   )
+  # end
+  # 
+  # # Helper class method to look up all flags for 
+  # # flaggable class name and flaggable id.
+  # def self.find_flags_for_flaggable(flaggable_str, flaggable_id)
+  #   find(:all,
+  #     :conditions => ["flaggable_type = ? and flaggable_id = ?", flaggable_str, flaggable_id],
+  #     :order => "created_at DESC"
+  #   )
+  # end
+  # 
+  # # Helper class method to look up a flaggable object
+  # # given the flaggable class name and id 
+  # def self.find_flaggable(flaggable_str, flaggable_id)
+  #   flaggable_str.constantize.find(flaggable_id)
+  # end
+end

data/test/can_be_flagged_options_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Article < ActiveRecord::Base
+end
+class Content < ActiveRecord::Base
+  set_table_name 'articles' # cheater
+end
+
+class CanBeFlaggedOptionsTest < Test::Unit::TestCase
+  def setup
+    Article.class_eval do
+      can_be_flagged :reasons => [:porn, :troll]
+    end
+  end
+
+  def test_sets_options_as_class_var
+    assert_equal [:porn, :troll], Article.reasons
+  end
+
+  def test_does_not_leak_reasons_betwixt_classes
+    Content.class_eval do
+      can_be_flagged :reasons => [:spam]
+    end
+    assert_equal [:porn, :troll], Article.reasons
+    assert_equal [:spam], Content.reasons
+  end
+end

data/test/content_association_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Article < ActiveRecord::Base
+end
+
+class ContentAssociationTest < Test::Unit::TestCase
+  
+  def test_article_can_has_flag
+    Article.class_eval {
+      can_be_flagged
+    }
+    assert_not_nil Article.reflect_on_association(:flags)
+    assert_equal :has_many, Article.reflect_on_association(:flags).macro, 
+      "Should create the 'flags' association"
+    #assert_not_nil Article.reflect_on_association(:flaggable)
+    #assert_equal :has_many, Article.reflect_on_association(:flaggable).macro, 
+    #  "Should create the 'flaggable' association"
+  end
+
+end

data/test/content_attributes_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Article < ActiveRecord::Base
+  can_be_flagged
+end
+
+class ContentAttributesTest < Test::Unit::TestCase
+  def test_article_cab_has_attributes_like_states
+    a = Article.new
+    assert a.respond_to?(:flagged?), "Should have the 'flagged?' method defined"
+    assert a.respond_to?(:flagged=), "Should have the 'flagged=' writer defined"
+  end
+  
+  def test_article_can_has_writer
+    a = Article.new
+    assert ! a.flagged?, "Article should not be flagged by default"
+    a.attributes = { 'flagged' => true }
+    assert a.flagged? 
+  end
+
+end

data/test/database.yml

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

data/test/flag_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Article < ActiveRecord::Base
+  can_be_flagged
+  attr_accessor :called_back
+  
+  def after_flagged
+    @called_back = true
+  end
+end
+
+class FlagTest < Test::Unit::TestCase
+  
+  def test_calls_back_to_article
+    article = Article.create :title => "My article", :body => "Five five five", :user_id => 1
+    assert ! article.called_back
+    flag = Flag.create! :flaggable => article
+    assert article.called_back, "Article should call 'after_flagged' callback"
+  end
+  
+  def test_sets_flaggable_user_id
+    article = Article.create :title => "My article", :body => "Five five five", :user_id => 1
+    flag = Flag.create :flaggable => article
+    flag.save!
+    assert_equal 1, flag.flaggable_user_id
+  end
+  
+  def test_only_allows_valid_reasons
+    Article.class_eval { can_be_flagged :reasons => [ :foolish ] }
+    article = Article.create :title => "My article", :body => "Five five five", :user_id => 1
+    flag = Flag.create :flaggable => article, :reason => "foolish"
+    assert flag.save!
+    flag.reason = "Monkeys"
+    assert ! flag.save
+  end
+end

data/test/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define(:version => 0) do
+  
+  create_table :articles do |t|
+    t.string :title
+    t.string :body
+    t.string :user_id
+  end
+
+  create_table :users do |t|
+    t.string :login
+  end
+  
+  create_table :flags do |t|
+    t.integer :user_id
+    t.integer :flaggable_id
+    t.string  :flaggable_type
+    t.integer :flaggable_user_id
+    t.string  :reason
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] ||= '~/dev/oss/altered_beast/' #File.dirname(__FILE__) + '/../../../..'
+
+require 'test/unit'
+require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+require 'active_record/fixtures'
+require 'action_controller/test_process'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+
+# Cargo culted from attachment_fu!
+db_adapter = ENV['DB']
+
+# no db passed, try one of these fine config-free DBs before bombing.
+db_adapter ||= 
+  begin
+    require 'rubygems'
+    require 'sqlite'
+    'sqlite'
+  rescue MissingSourceFile
+    begin
+      require 'sqlite3'
+      'sqlite3'
+    rescue MissingSourceFile
+    end
+  end
+
+if db_adapter.nil?
+  raise "No DB Adapter selected.  Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+end
+
+ActiveRecord::Base.establish_connection(config[db_adapter])
+
+load(File.dirname(__FILE__) + "/schema.rb")
+
+# Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures"
+# $LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)

data/test/user_association_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class User<ActiveRecord::Base; end
+
+class UserAssociationTest < Test::Unit::TestCase
+  def test_creates_user_association_in_flag
+    assert_nil Flag.reflect_on_association(:user)
+    User.class_eval do
+      can_flag
+    end
+    assert_not_nil Flag.reflect_on_association(:user)
+  end
+end
+
+class User2<ActiveRecord::Base; set_table_name :users; end
+
+class UserFlagAssociationTest < Test::Unit::TestCase
+  
+  def test_creates_flaggable_associations_in_user
+    assert_nil User2.reflect_on_association(:flaggable)
+    User2.class_eval do 
+      can_flag
+    end
+    assert_not_nil User2.reflect_on_association(:flaggings)
+    assert_equal :has_many, User2.reflect_on_association(:flaggings).macro
+    assert_nothing_raised { User2.new.flaggings }
+    assert_not_nil User2.reflect_on_association(:flags)
+    assert_equal :has_many, User2.reflect_on_association(:flags).macro
+    assert_nothing_raised { User2.new.flags }
+  end
+  
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: can_flag
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Courtenay Gasking
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: 
+- courtenay@entp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+files: 
+- lib/can_flag/rails_commands.rb
+- lib/can_flag.rb
+- lib/flag.rb
+- test/can_be_flagged_options_test.rb
+- test/content_association_test.rb
+- test/content_attributes_test.rb
+- test/database.yml
+- test/flag_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- test/user_association_test.rb
+- MIT-LICENSE
+- README
+has_rdoc: true
+homepage: http://github.com/courtenay/can_flag
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rails plugin to allow users to flag content for review
+test_files: 
+- test/can_be_flagged_options_test.rb
+- test/content_association_test.rb
+- test/content_attributes_test.rb
+- test/flag_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- test/user_association_test.rb