commontator 4.0.1 → 4.0.2

data/app/controllers/commontator/threads_controller.rb~

@@ -1,42 +0,0 @@
-module Commontator
-  class ThreadsController < Commontator::ApplicationController
-    before_filter :get_thread
-    before_filter :set_commontable_url, :only => :show
-
-    # GET /threads/1
-    def show
-      commontator_thread_show(@thread.commontable)
-
-      respond_to do |format|
-        format.html { redirect_to commontable_url }
-        format.js
-      end
-    end
-    
-    # PATCH /threads/1/close
-    def close
-      raise SecurityTransgression unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, 'This thread has already been closed.') \
-        unless @thread.close(@user)
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
-      end
-    end
-    
-    # PUT /threads/1/reopen
-    def reopen
-      raise SecurityTransgression unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, 'This thread is not closed.') \
-        unless @thread.reopen
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
-      end
-    end
-  end
-end

data/app/mailers/commontator/subscriptions_mailer.rb~

@@ -1,50 +0,0 @@
-module Commontator
-  class SubscriptionsMailer < ActionMailer::Base
-    include SharedHelper
-    include ThreadsHelper
-  
-    def comment_created(comment, recipients)
-      setup_variables(comment, recipients)
-
-      mail :to => 'Undisclosed Recipients'
-           :bcc => @bcc,
-           :from => @from,
-           :subject => @subject
-    end
-
-    protected
-
-    def setup_variables(comment, recipients)
-      @comment = comment
-      @thread = @comment.thread
-      @creator = @comment.creator
-      
-      @commontable = @thread.commontable
-      @config = @thread.config
-      
-      @creator_name = commontator_name(@creator)
-      @comment_timestamp = @comment.timestamp
-      
-      @commontable_name = commontable_name(@thread)
-      @commontable_id = commontable_id(@thread).to_s
-      
-      @commontable_url = ApplicationController.commontable_url
-      
-      params = Hash.new
-      params[:comment] = @comment
-      params[:thread] = @thread
-      params[:creator] = @creator
-      params[:commontable] = @commontable
-      params[:config] = @config
-      params[:creator_name] = @creator_name
-      params[:comment_timestamp] = @comment_timestamp
-      params[:commontable_name] = @commontable_name
-      params[:commontable_id] = @commontable_id
-      params[:commontable_url] = @commontable_url
-      
-      @bcc = recipients.collect{|s| commontator_email(s)}
-      @from = @config.subscription_email_from_proc.call(params)
-      @subject = @config.subscription_email_subject_proc.call(params)
-    end
-  end
-end

data/app/models/commontator/comment.rb~

@@ -1,104 +0,0 @@
-module Commontator
-  class Comment < ActiveRecord::Base
-    belongs_to :creator, :polymorphic => true
-    belongs_to :editor, :polymorphic => true
-    belongs_to :thread
-
-    has_one :commontable, :through => :thread
-
-    attr_accessible :body if respond_to?(:attr_accessible)
-
-    validates_presence_of :creator, :on => :create
-    validates_presence_of :editor, :on => :update
-    validates_presence_of :thread
-    validates_presence_of :body
-
-    validates_uniqueness_of :body, :scope => [:creator_type, :creator_id, :thread_id],
-                                   :message => 'has already been posted'
-
-    protected
-
-    cattr_accessor :acts_as_votable_initialized
-
-    public
-
-    def is_votable?
-      return true if acts_as_votable_initialized
-      return false unless self.class.respond_to?(:acts_as_votable)
-      self.class.acts_as_votable
-      self.class.acts_as_votable_initialized = true
-    end
-
-    def get_vote_by(user)
-      return nil unless is_votable?
-      votes.where(:voter_type => user.class.name, :voter_id => user.id).first
-    end
-
-    def is_modified?
-      !editor.nil?
-    end
-
-    def is_deleted?
-      !deleted_at.blank?
-    end
-
-    def delete_by(user)
-      return false if is_deleted?
-      self.deleted_at = Time.now
-      self.editor = user
-      self.save
-    end
-
-    def undelete_by(user)
-      return false unless is_deleted?
-      self.deleted_at = nil
-      self.editor = user
-      self.save
-    end
-
-    def timestamp
-      config = thread.config
-      "#{config.comment_create_verb_past.capitalize} on " + \
-        created_at.strftime(config.timestamp_format) + \
-        (is_modified? ? " | Last #{config.comment_edit_verb_past} on " + \
-          updated_at.strftime(config.timestamp_format) : '')
-    end
-
-    ##################
-    # Access Control #
-    ##################
-
-    def can_be_read_by?(user)
-      (thread.can_be_read_by?(user) && \
-        (!is_deleted? || thread.config.deleted_comments_are_visible)) ||\
-        thread.can_be_edited_by?(user)
-    end
-
-    def can_be_created_by?(user)
-      !thread.is_closed? && thread.can_be_read_by?(user) && user == creator
-    end
-
-    def can_be_edited_by?(user)
-      !thread.is_closed? && !is_deleted? &&\
-        ((user == creator && thread.config.can_edit_own_comments && thread.can_be_read_by?(user)) ||\
-        (thread.can_be_edited_by?(user) && thread.config.admin_can_edit_comments)) &&\
-        (thread.comments.last == self || thread.config.can_edit_old_comments)
-    end
-
-    def can_be_deleted_by?(user)
-      (!thread.is_closed? &&\
-        ((user == creator && thread.config.can_delete_own_comments && \
-        thread.can_be_read_by?(user) && (!is_deleted? || editor == user)) &&\
-        (thread.comments.last == self || thread.config.can_delete_old_comments))) ||\
-        thread.can_be_edited_by?(user)
-    end
-
-    def can_be_voted_on?
-      !thread.is_closed? && is_votable? && !is_deleted? && thread.config.can_vote_on_comments
-    end
-
-    def can_be_voted_on_by?(user)
-      can_be_voted_on? && thread.can_be_read_by?(user) && user != creator
-    end
-  end
-end

data/app/models/commontator/subscription.rb~

@@ -1,18 +0,0 @@
-module Commontator
-  class Subscription < ActiveRecord::Base
-    belongs_to :subscriber, :polymorphic => true
-
-    belongs_to :thread
-
-    validates_presence_of :subscriber, :thread
-    validates_uniqueness_of :thread_id, :scope => [:subscriber_type, :subscriber_id]
-
-    def mark_as_read
-      update_attribute(:unread, 0)
-    end
-
-    def add_unread
-      update_attribute(:unread, unread + 1)
-    end
-  end
-end

data/app/models/commontator/thread.rb~

@@ -1,124 +0,0 @@
-module Commontator
-  class Thread < ActiveRecord::Base
-    belongs_to :closer, :polymorphic => true
-    belongs_to :commontable, :polymorphic => true
-
-    has_many :comments, :dependent => :destroy
-    has_many :subscriptions, :dependent => :destroy
-
-    validates_presence_of :commontable, :unless => :is_closed?
-    validates_uniqueness_of :commontable_id, :scope => :commontable_type, :allow_nil => true
-
-    def config
-      commontable.try(:commontable_config) || Commontator
-    end
-
-    def ordered_comments
-      (config.can_vote_on_comments && config.comments_ordered_by_votes) ? \
-        comments.order("cached_votes_down - cached_votes_up") : comments
-    end
-
-    def is_closed?
-      !closed_at.blank?
-    end
-
-    def subscribers
-      subscriptions.collect{|s| s.subscriber}
-    end
-
-    def active_subscribers
-      subscribers.select{|s| s.is_commontator && s.commontator_config.subscription_email_enable_proc.call(s)}
-    end
-
-    def subscription_for(subscriber)
-      return nil if subscriber.nil? || !subscriber.is_commontator
-      subscriber.subscriptions.where(:thread_id => self.id).first
-    end
-
-    def is_subscribed?(subscriber)
-      !subscription_for(subscriber).blank?
-    end
-
-    def subscribe(subscriber)
-      return false if is_subscribed?(subscriber) || !subscriber.is_commontator
-      subscription = Subscription.new
-      subscription.subscriber = subscriber
-      subscription.thread => self
-      subscription.save
-    end
-
-    def unsubscribe(subscriber)
-      subscription = subscription_for(subscriber)
-      return false if subscription.blank?
-      subscription.destroy
-    end
-
-    def add_unread_except_for(subscriber)
-      Subscription.transaction do
-        subscriptions.each{|s| s.add_unread unless s.subscriber == subscriber}
-      end
-    end
-
-    def mark_as_read_for(subscriber)
-      return if !subscription_for(subscriber)
-      subscription_for(subscriber).mark_as_read
-    end
-
-    def close(user = nil)
-      return false if is_closed?
-      self.closed_at = Time.now
-      self.closer = user
-      save
-    end
-
-    def reopen
-      return false unless is_closed? && !commontable.nil?
-      self.closed_at = nil
-      save
-    end
-
-    # Creates a new empty thread and assigns it to the commontable
-    # The old thread is kept in the database for archival purposes
-    def clear(user = nil)
-      return if commontable.blank?
-      new_thread = Thread.new
-      new_thread.commontable = commontable
-      with_lock do
-        self.commontable = nil
-        self.closed_at = Time.now
-        self.closer = user
-        save!
-        new_thread.save!
-        subscriptions.each do |s|
-          s.thread = new_thread
-          s.save!
-          s.mark_as_read
-        end
-      end
-    end
-
-    ##################
-    # Access Control #
-    ##################
-
-    # Reader and poster capabilities
-    def can_be_read_by?(user)
-      (!commontable.nil? && \
-        (!is_closed? || config.closed_threads_are_readable) && \
-        config.can_read_thread_proc.call(self, user)) || \
-        can_be_edited_by?(user)
-    end
-
-    # Thread moderator capabilities
-    def can_be_edited_by?(user)
-      (!commontable.nil? && \
-        config.can_edit_thread_proc.call(self, user)) || \
-        (!user.nil? && user.is_commontator && \
-        user.commontator_config.user_admin_proc.call(user))
-    end
-
-    def can_subscribe?(user)
-      !commontable.nil? && config.can_subscribe_to_thread && !is_closed? && can_be_read_by?(user)
-    end
-  end
-end

data/app/models/commontator/tree.rb~

@@ -1,123 +0,0 @@
-module Linkifier
-  class Tree < ActiveRecord::Base
-    belongs_to :closer, :polymorphic => true
-    belongs_to :commontable, :polymorphic => true
-
-    has_many :comments, :dependent => :destroy
-    has_many :subscriptions, :dependent => :destroy
-
-    validates_presence_of :commontable, :on => :create
-    
-    attr_accessible :is_closed
-    
-    def config
-      commontable.try(:commontable_config)
-    end
-    
-    def ordered_comments
-      (!commontable.blank? && config.can_vote_on_comments && config.comments_ordered_by_votes) ? \
-        comments.order("cached_votes_down - cached_votes_up") : comments
-    end
-    
-    def subscribers
-      subscriptions.collect{|s| s.subscriber}
-    end
-    
-    def active_subscribers
-      subscribers.select{|s| s.commontator_config.subscription_email_enable_proc.call(s)}
-    end
-    
-    def subscription_for(subscriber)
-      return nil if subscriber.nil?
-      Subscription.find_by_thread_id_and_subscriber_id_and_subscriber_type(self.id, subscriber.id, subscriber.class.name)
-    end
-    
-    def is_closed?
-      !closed_at.blank?
-    end
-    
-    def is_subscribed?(subscriber)
-      !subscription_for(subscriber).blank?
-    end
-
-    def subscribe(subscriber)
-      return false if is_subscribed?(subscriber)
-      subscription = Subscription.create(
-        :subscriber => subscriber, :thread => self)
-    end
-
-    def unsubscribe(subscriber)
-      subscription = subscription_for(subscriber)
-      return false if subscription.blank?
-      subscription.destroy
-    end
-
-    def mark_as_read_for(subscriber)
-      return if !subscription_for(subscriber)
-      subscription_for(subscriber).mark_as_read
-    end
-    
-    def add_unread_except_for(subscriber)
-      Subscription.transaction do
-        subscriptions.each{|s| s.add_unread unless s.subscriber == subscriber}
-      end
-    end
-    
-    def close(user = nil)
-      return false if is_closed?
-      self.closed_at = Time.now
-      self.closer = user
-      self.save!
-    end
-    
-    def reopen
-      return false unless is_closed?
-      self.closed_at = nil
-      self.save!
-    end
-    
-    # Creates a new empty thread and assigns it to the commontable
-    # The old thread is kept in the database for archival purposes
-    
-    def clear(user = nil)
-      return if commontable.blank?
-      new_thread = Thread.new
-      new_thread.commontable = commontable
-      self.with_lock do
-        new_thread.save!
-        commontable.thread = new_thread
-        commontable.save!
-        subscriptions.each do |s|
-          s.thread = new_thread
-          s.save!
-          s.mark_as_read
-        end
-        self.commontable = nil
-        self.close(user)
-      end
-    end
-
-    ##########################
-    # Access control methods #
-    ##########################
-    
-    # Reader and poster capabilities
-    def can_be_read_by?(user)
-      (!commontable.blank? && \
-        (!is_closed? || config.closed_threads_are_readable) && \
-        config.can_read_thread_proc.call(self, user)) || \
-        can_be_edited_by?(user)
-    end
-
-    # Thread moderator capabilities
-    def can_be_edited_by?(user)
-      !commontable.blank? && \
-        (config.can_edit_thread_proc.call(self, user) || \
-        (!user.nil? && user.commontator_config.user_admin_proc.call(user)))
-    end
-
-    def can_subscribe?(user)
-      !commontable.blank? && config.can_subscribe_to_thread && !is_closed? && can_be_read_by?(user)
-    end
-  end
-end