community_engine 2.3.2 → 3.0.0

data/app/helpers/friendships_helper.rb

@@ -3,11 +3,11 @@ module FriendshipsHelper
   def friendship_control_links(friendship)
     html = case friendship.friendship_status_id
       when FriendshipStatus[:pending].id
-        "#{(link_to(:accept.l, accept_user_friendship_path(friendship.user, friendship), :method => :put, :class => 'button positive') unless friendship.initiator?)} #{link_to(:deny.l, deny_user_friendship_path(friendship.user, friendship), :method => :put, :class => 'button negative')}"
+        "#{(link_to(:accept.l, accept_user_friendship_path(friendship.user, friendship), :method => :patch, :class => 'button positive') unless friendship.initiator?)} #{link_to(:deny.l, deny_user_friendship_path(friendship.user, friendship), :method => :patch, :class => 'button negative')}"
       when FriendshipStatus[:accepted].id
-        "#{link_to(:remove_this_friend.l, deny_user_friendship_path(friendship.user, friendship), :method => :put, :class => 'button negative')}"
+        "#{link_to(:remove_this_friend.l, deny_user_friendship_path(friendship.user, friendship), :method => :patch, :class => 'button negative')}"
       when FriendshipStatus[:denied].id
-    		"#{link_to(:accept_this_request.l, accept_user_friendship_path(friendship.user, friendship), :method => :put, :class => 'button positive')}"
+    		"#{link_to(:accept_this_request.l, accept_user_friendship_path(friendship.user, friendship), :method => :patch, :class => 'button positive')}"
     end
     
     html.html_safe

data/app/helpers/posts_helper.rb

@@ -4,13 +4,11 @@ module PostsHelper
   # Facebook seems to ignore them (it uses title and description meta tags
   # instead).  MySpace, however, only works if you set these attributes.
   def sharethis_options(post)
-    content_tag :script, :type=>"text/javascript" do   
-      <<-eos
-	SHARETHIS.addEntry({
-		title:'#{escape_javascript(post.title)}',
-                content:'#{escape_javascript(truncate_words(post.post, 75, '...' ))}'
-	}, {button:true});
-      eos
+    content_tag :script, :type=>"text/javascript" do
+        "SHARETHIS.addEntry({
+          title:'#{escape_javascript(post.title)}',
+          content:'#{escape_javascript(truncate_words(post.post, 75, '...' ))}'
+        }, {button:true});".html_safe
     end
   end
 

data/app/models/acts_as_taggable_on/tag.rb

@@ -1,4 +1,4 @@
-require_dependency ActsAsTaggableOn::Engine.config.root.join('app', 'models', 'acts_as_taggable_on', 'tag.rb').to_s
+#require_dependency ActsAsTaggableOn::Engine.config.root.join('app', 'models', 'acts_as_taggable_on', 'tag.rb').to_s
 
 class ActsAsTaggableOn::Tag < ActiveRecord::Base
 
@@ -29,13 +29,12 @@ class ActsAsTaggableOn::Tag < ActiveRecord::Base
     def counts(options = {})
       options.assert_valid_keys :start_at, :end_at, :at_least, :at_most, :conditions, :limit, :order, :joins
 
-      tags = joins(:taggings)
+      tags = select("#{quoted_table_name}.id", "#{quoted_table_name}.name", "COUNT(#{quoted_table_name}.id) AS count")
+      tags = tags.joins(:taggings)
       tags = tags.having(["COUNT(#{ActsAsTaggableOn::Tagging.quoted_table_name}.id) >= ?", options[:at_least]]) if options[:at_least]
       tags = tags.having(["COUNT(#{ActsAsTaggableOn::Tagging.quoted_table_name}.id) <= ?", options[:at_most]])  if options[:at_most]
       tags = tags.where("#{ActsAsTaggableOn::Tagging.quoted_table_name}.created_at >= ?", options[:start_at]) if options[:start_at]
       tags = tags.where("#{ActsAsTaggableOn::Tagging.quoted_table_name}.created_at <= ?", options[:end_at])   if options[:end_at]
-
-      # TODO: deprecation warning
       tags = tags.where(options[:conditions]) if options[:conditions]
       tags = tags.limit(options[:limit])      if options[:limit]
       tags = tags.order(options[:order])      if options[:order]
@@ -44,7 +43,7 @@ class ActsAsTaggableOn::Tag < ActiveRecord::Base
         tags = tags.joins(joins)
       end
 
-      tags.select("#{quoted_table_name}.id, #{quoted_table_name}.name, COUNT(#{quoted_table_name}.id) AS count").group("#{quoted_table_name}.id, #{quoted_table_name}.name")
+      tags.group("#{quoted_table_name}.id, #{quoted_table_name}.name")
     end
 
 
@@ -55,18 +54,18 @@ class ActsAsTaggableOn::Tag < ActiveRecord::Base
   end
 
   def related_tags(limit = 10)
-    taggables = self.taggings.limit(10).all.collect{|t| t.taggable }.compact
+    taggables = self.taggings.limit(10).to_a.collect{|t| t.taggable }.compact
 
     tagging_ids = taggables.map{|t| t.taggings.limit(10).map(&:id) }.flatten.uniq
     return [] if tagging_ids.blank?
 
-    ActsAsTaggableOn::Tag.where("tags.id != '#{self.id}'").
-      select("tags.id, tags.name, COUNT(tags.id) as count").
-      joins(:taggings).
-      where({:taggings => {:id => tagging_ids }}).
-      group("tags.id, tags.name").
-      order("count DESC").
-      limit(limit)
+    ActsAsTaggableOn::Tag.where("tags.id != '#{self.id}'")
+      .select("tags.id, tags.name, COUNT(tags.id) as count")
+      .joins(:taggings)
+      .where({:taggings => {:id => tagging_ids }})
+      .group("tags.id, tags.name")
+      .order("count DESC")
+      .limit(limit)
   end
 
 end

data/app/models/ad.rb

@@ -6,17 +6,14 @@ class Ad < ActiveRecord::Base
   validates_inclusion_of :audience, :in => AUDIENCES
   validates_inclusion_of :frequency, :in => FREQUENCIES
 
-  attr_accessible :html, :name, :frequency, :audience, :published, :time_constrained, :start_date, :end_date, :location
-
 
   def self.display(location, logged_in = false)
     return nil if location.blank?
-    ads = find(:all,
-      :conditions => ["location = ?
+    ads = where("location = ?
         AND published = ?
         AND (time_constrained = ? OR (start_date > ? AND end_date < ?))
         AND (audience IN (?) )",
-        location.to_s, true, false, Time.now, Time.now, audiences_for(logged_in) ])
+        location.to_s, true, false, Time.now, Time.now, audiences_for(logged_in))
 
     ad = random_weighted(ads.map{|a| [a, a.frequency] })
     ad ? ad.html.html_safe : ''

data/app/models/album.rb

@@ -6,8 +6,6 @@ class Album < ActiveRecord::Base
   acts_as_moderated_commentable
   validates_presence_of :title
 
-  attr_accessible :title, :description, :user_id
-
   def owner
     self.user
   end

data/app/models/category.rb

@@ -1,13 +1,12 @@
 class Category < ActiveRecord::Base
-  has_many :posts, :order => "published_at desc"
+  extend FriendlyId
+  has_many :posts, -> { order("published_at desc") }
   validates_presence_of :name
-  
-  attr_accessible :name, :tips, :new_post_text, :nav_text
-  
-  has_friendly_id :name, :use_slug => true
-      
+
+  friendly_id :name, :use => [:slugged, :finders]
+
   def display_new_post_text
     new_post_text
   end
-  
+
 end

data/app/models/clipping.rb

@@ -17,10 +17,7 @@ class Clipping < ActiveRecord::Base
   acts_as_taggable
   acts_as_activity :user
 
-  attr_accessible :user, :url, :description, :image_url
-
-  scope :recent, :order => 'clippings.created_at DESC'
-
+  scope :recent, lambda { order('clippings.created_at DESC') }
 
   def self.find_related_to(clipping, options = {})
     options.reverse_merge!({:limit => 8,
@@ -35,7 +32,7 @@ class Clipping < ActiveRecord::Base
   end
 
   def self.find_recent(options = {:limit => 5})
-    find(:all, :conditions => "created_at > '#{7.days.ago.iso8601}'", :order => "created_at DESC", :limit => options[:limit])
+    where("created_at > '#{7.days.ago.iso8601}'").order("created_at DESC").limit(options[:limit])
   end
 
   def previous_clipping

data/app/models/clipping_image.rb

@@ -1,9 +1,9 @@
 class ClippingImage < Asset
   include UrlUpload
-  
-  has_attached_file :asset, configatron.clipping.paperclip_options
-  validates_attachment_presence :asset, :message => :photo_presence_error.l
-  validates_attachment_content_type :asset, :content_type => configatron.clipping.validation_options.content_type, :message => :photo_content_type_error.l
-  validates_attachment_size :asset, :less_than => configatron.clipping.validation_options.max_size.to_i.megabytes, :message => :photo_size_limit_error.l(:count => configatron.clipping.validation_options.max_size)
+
+  has_attached_file :asset, configatron.clipping.paperclip_options.to_hash
+  validates_attachment_presence :asset
+  validates_attachment_content_type :asset, :content_type => configatron.clipping.validation_options.content_type
+  validates_attachment_size :asset, :less_than => configatron.clipping.validation_options.max_size.to_i.megabytes
 
 end

data/app/models/comment.rb

@@ -2,7 +2,6 @@ class Comment < ActiveRecord::Base
   include ActsAsCommentable::Comment
   include Rakismet::Model
   rakismet_attrs :author => :author_name, :comment_type => 'comment', :content => :comment, :user_ip => :author_ip
-  attr_protected :akismet_attrs
 
   belongs_to :commentable, :polymorphic => true
   belongs_to :user, :inverse_of => :comments_as_author, :foreign_key => 'user_id', :class_name => "User"
@@ -25,7 +24,7 @@ class Comment < ActiveRecord::Base
   acts_as_activity :user, :if => Proc.new{|record| record.user && !record.pending? } #don't record an activity if there's no user
 
   def self.find_photo_comments_for(user)
-    Comment.find(:all, :conditions => ["recipient_id = ? AND commentable_type = ?", user.id, 'Photo'], :order => 'created_at DESC')
+    Comment.where("recipient_id = ? AND commentable_type = ?", user.id, 'Photo').order('created_at DESC')
   end
 
   def previous_commenters_to_notify
@@ -66,7 +65,7 @@ class Comment < ActiveRecord::Base
   end
 
   def self.find_recent(options = {:limit => 5})
-    find(:all, :conditions => "created_at > '#{14.days.ago.iso8601}'", :order => "created_at DESC", :limit => options[:limit])
+    where("created_at > '#{14.days.ago.iso8601}'").order("created_at DESC").limit(options[:limit])
   end
 
   def can_be_deleted_by(person)
@@ -106,13 +105,13 @@ class Comment < ActiveRecord::Base
   end
 
   def unsubscribe_notifications(email)
-    commentable.comments.find_all_by_author_email(email).each do |previous_comment|
+    commentable.comments.where(:author_email => email).each do |previous_comment|
       previous_comment.update_attribute :notify_by_email, false
     end
   end
 
   def check_spam
-    if !configatron.akismet_key.nil? && self.spam?
+    if configatron.has_key?(:akismet_key) && self.spam?
       self.role = 'pending'
     end
   end

data/app/models/country.rb

@@ -1,8 +1,6 @@
 class Country < ActiveRecord::Base
   has_many :metro_areas
 
-  attr_accessible :name
-  
   def self.get(name)
     case name
       when :us
@@ -12,11 +10,11 @@ class Country < ActiveRecord::Base
   end
   
   def self.find_countries_with_metros
-    Country.joins(:metro_areas).where('metro_areas.id IS NOT NULL').order('countries.name ASC').all.uniq
+    Country.joins(:metro_areas).where('metro_areas.id IS NOT NULL').order('countries.name ASC').to_a.uniq
   end
   
   def states
-    State.joins(:metro_areas).where("metro_areas.id in (?)", metro_area_ids ).order('states.name ASC').all.uniq
+    State.joins(:metro_areas).where("metro_areas.id in (?)", metro_area_ids ).order('states.name ASC').to_a.uniq
   end
   
   def metro_area_ids

data/app/models/event.rb

@@ -11,8 +11,7 @@ class Event < ActiveRecord::Base
   has_many :rsvps, :dependent=>:destroy
   has_many :attendees, :source=>:user, :through=>:rsvps
 
-  attr_protected :user_id
-
+  
   #Procs used to make sure time is calculated at runtime
   scope :upcoming, lambda {
     where('end_time > ?' , Time.now).order('start_time ASC')

data/app/models/favorite.rb

@@ -14,10 +14,8 @@ class Favorite < ActiveRecord::Base
   validates_uniqueness_of :ip_address, :scope => [:favoritable_type, :favoritable_id], :message => 'has already favorited this item.', :if => Proc.new{|f| f.user.nil? }
   
   #named scopes
-  scope :recent, :order => "created_at DESC"
-  scope :by_user, lambda { |user|
-    {:conditions => ["user_id = ?", user.id] }
-  }
+  scope :recent, ->  { order("created_at DESC") }
+  scope :by_user, lambda { |user| where("user_id = ?", user.id) }
 
   
   def update_counter_on_favoritable
@@ -27,19 +25,16 @@ class Favorite < ActiveRecord::Base
   end
   
   def self.find_favorites_by_user(user)
-    find(:all,
-      :conditions => ["user_id = ?", user.id],
-      :order => "created_at DESC"
-    )
+    where("user_id = ?", user.id).order("created_at DESC")
   end
   
   def self.find_by_user_or_ip_address(favoritable = nil, user = nil, remote_ip = nil)
     return false unless favoritable && (user || remote_ip)
     
     if user
-      favorite = self.find(:first, :conditions => ["user_id = ? AND favoritable_type = ? AND favoritable_id = ?", user.id, favoritable.class.to_s, favoritable.id])
+      favorite = self.where("user_id = ? AND favoritable_type = ? AND favoritable_id = ?", user.id, favoritable.class.to_s, favoritable.id).first
     else
-      favorite = self.find(:first, :conditions => ["ip_address = ? AND favoritable_type = ? AND favoritable_id = ?", remote_ip, favoritable.class.to_s, favoritable.id])      
+      favorite = self.where("ip_address = ? AND favoritable_type = ? AND favoritable_id = ?", remote_ip, favoritable.class.to_s, favoritable.id).first
     end
     return favorite
   end

data/app/models/forum.rb

@@ -14,8 +14,6 @@ class Forum < ActiveRecord::Base
   belongs_to :owner, :polymorphic => true
 
   format_attribute :description
-
-  attr_accessible :name, :position, :description
   
   def to_param
     id.to_s << "-" << (name ? name.parameterize : '' )

data/app/models/friendship.rb

@@ -19,7 +19,7 @@ class Friendship < ActiveRecord::Base
   # named scopes
   scope :accepted, lambda {
     #hack: prevents FriendshipStatus[:accepted] from getting called before the friendship_status records are in the db (only matters in testing ENV)
-    {:conditions => ["friendship_status_id = ?", FriendshipStatus[:accepted].id]    }
+    where("friendship_status_id = ?", FriendshipStatus[:accepted].id)
   }
   
   def cannot_request_if_daily_limit_reached  
@@ -30,11 +30,9 @@ class Friendship < ActiveRecord::Base
     
   before_validation(:on => :create){:set_pending}
   after_save :notify_requester, :if => Proc.new{|fr| fr.accepted? && fr.initiator }
-
-  attr_protected :friendship_status_id
   
   def reverse
-    Friendship.find(:first, :conditions => ['user_id = ? and friend_id = ?', self.friend_id, self.user_id])
+    Friendship.where('user_id = ? and friend_id = ?', self.friend_id, self.user_id).first
   end
 
   def denied?
@@ -50,7 +48,7 @@ class Friendship < ActiveRecord::Base
   end
   
   def self.friends?(user, friend)
-    find(:first, :conditions => ["user_id = ? AND friend_id = ? AND friendship_status_id = ?", user.id, friend.id, FriendshipStatus[:accepted].id ])
+    where("user_id = ? AND friend_id = ? AND friendship_status_id = ?", user.id, friend.id, FriendshipStatus[:accepted].id).first
   end
   
   def notify_requester

data/app/models/friendship_status.rb

@@ -1,5 +1,3 @@
 class FriendshipStatus < ActiveRecord::Base
   acts_as_enumerated
-
-  attr_accessible :name
 end

data/app/models/homepage_feature.rb

@@ -1,15 +1,13 @@
 class HomepageFeature < ActiveRecord::Base  
   has_attached_file :image, configatron.feature.paperclip_options.to_hash
-  validates_attachment_presence :image, :message => :photo_presence_error.l
-  validates_attachment_content_type :image, :content_type => configatron.feature.validation_options.content_type, :message => :photo_content_type_error.l
-  validates_attachment_size :image, :less_than => configatron.feature.validation_options.max_size.to_i.megabytes, :message => :photo_size_limit_error.l(:count => configatron.feature.validation_options.max_size)
-
-  attr_accessible :url, :title, :description, :image
+  validates_attachment_presence :image
+  validates_attachment_content_type :image, :content_type => configatron.feature.validation_options.content_type
+  validates_attachment_size :image, :less_than => configatron.feature.validation_options.max_size.to_i.megabytes
 
   validates_presence_of :url
   
   def self.find_features
-    find(:all, :order => "created_at DESC")
+    order("created_at DESC")
   end
 
 end

data/app/models/invitation.rb

@@ -1,8 +1,8 @@
 class Invitation < ActiveRecord::Base
   acts_as_activity :user
-  
+
   belongs_to :user
-  
+
   after_save :send_invite
 
   validates_presence_of :user
@@ -14,11 +14,11 @@ class Invitation < ActiveRecord::Base
     invalid_emails = []
     email_addresses = email_addresses || ''
     emails = email_addresses.split(",").collect{|email| email.strip }.uniq
-    
+
     emails.each{ |email|
       unless email =~ /[\w._%-]+@[\w.-]+.[a-zA-Z]{2,4}/
         invalid_emails << email
-      end        
+      end
     }
     unless invalid_emails.empty?
       record.errors.add(:email_addresses, " included invalid addresses: <ul>"+invalid_emails.collect{|email| '<li>'+email+'</li>' }.join+"</ul>")
@@ -26,13 +26,11 @@ class Invitation < ActiveRecord::Base
     end
   end
 
-  attr_accessible :email_addresses, :message
-
   def send_invite
-    emails = self.email_addresses.split(",").collect{|email| email.strip }.uniq 
+    emails = self.email_addresses.split(",").collect{|email| email.strip }.uniq
     emails.each{|email|
       UserNotifier.signup_invitation(email, self.user, self.message).deliver
     }
   end
-  
+
 end

data/app/models/message.rb

@@ -1,44 +1,43 @@
-class Message < ActiveRecord::Base  
+class Message < ActiveRecord::Base
   attr_accessor :to
   attr_accessor :reply_to
 
-  attr_accessible :to, :subject, :body, :recipient, :sender, :recipient_id, :sender_id, :parent_id
-
   belongs_to :sender,     :class_name => 'User', :foreign_key => 'sender_id', :inverse_of => :sent_messages
   belongs_to :recipient,  :class_name => 'User', :foreign_key => 'recipient_id', :inverse_of => :received_messages
 
   belongs_to :parent, :class_name => "Message", :foreign_key => "parent_id", :inverse_of => :children
   has_many :children, :class_name => "Message", :foreign_key => "parent_id", :inverse_of => :parent
   has_many :message_threads
-  
-  scope :parent_messages, where("parent_id IS NULL")
-  scope :already_read, where("read_at IS NOT NULL")
-  scope :unread, where("read_at IS NULL")
-  
+
+  scope :parent_messages, -> { where("parent_id IS NULL") }
+  scope :already_read, -> { where("read_at IS NOT NULL") }
+  scope :unread, -> { where("read_at IS NULL") }
+  scope :reader, lambda { |reader| where("sender_id = ? OR recipient_id = ?", reader, reader)}
+
   validates_presence_of :body, :subject, :sender
   validates_presence_of :recipient, :message => "is invalid"
   validate :ensure_not_sending_to_self
-  
+
   after_create :notify_recipient
   after_create :update_message_threads
-  
-  
+
+
   # Ensures the passed user is either the sender or the recipient then returns the message.
   # If the reader is the recipient and the message has yet not been read, it marks the read_at timestamp.
   def self.read(id, reader)
-    message = find(id, :conditions => ["sender_id = ? OR recipient_id = ?", reader, reader])
+    message = self.reader(reader).find(id)
     if message.read_at.nil? && reader == message.recipient
       message.read_at = Time.now
       message.save!
     end
     message
   end
-  
+
   # Returns true or false value based on whether the a message has been read by its recipient.
   def read?
     self.read_at.nil? ? false : true
   end
-  
+
   # Marks a message as deleted by either the sender or the recipient, which ever the user that was passed is.
   # Once both have marked it deleted, it is destroyed.
   def mark_deleted(user)
@@ -46,35 +45,35 @@ class Message < ActiveRecord::Base
     self.recipient_deleted = true if self.recipient == user
     self.sender_deleted && self.recipient_deleted ? self.destroy : save!
   end
-  
-  
+
+
   def ensure_not_sending_to_self
-    errors.add(:base, "You may not send a message to yourself.") if self.recipient && self.recipient.eql?(self.sender)    
+    errors.add(:base, "You may not send a message to yourself.") if self.recipient && self.recipient.eql?(self.sender)
   end
-  
+
   def notify_recipient
     UserNotifier.message_notification(self).deliver
   end
-  
+
   def update_message_threads
-    recipients_thread = MessageThread.find_or_create_by_recipient_id_and_parent_message_id(self.recipient_id, (self.parent_id || self.id))
+    recipients_thread = MessageThread.find_or_create_by(:recipient_id => self.recipient_id, :parent_message_id =>  (self.parent_id || self.id))
     recipients_thread.sender = sender
     recipients_thread.recipient = recipient
     recipients_thread.message = self
     recipients_thread.parent_message = (self.parent || self)
     recipients_thread.save
-  
+
     if parent
-      senders_thread = MessageThread.find_or_create_by_recipient_id_and_parent_message_id(self.sender_id, self.parent_id)
+      senders_thread = MessageThread.find_or_create_by(:recipient_id => self.sender_id, :parent_message_id => self.parent_id)
       senders_thread.message = self
       senders_thread.save
     end
   end
-  
+
   def self.new_reply(sender, message_thread = nil, params = {})
     message = new(params[:message])
     message.to ||= params[:to] if params[:to]
-  
+
     if message_thread
       message.parent = message_thread.parent_message
       message.reply_to = message_thread.message
@@ -82,8 +81,8 @@ class Message < ActiveRecord::Base
       message.subject = message_thread.parent_message.subject
       message.sender = sender
     end
-  
+
     message
   end
-    
+
 end