commontator 4.6.0 → 4.6.1

data/app/assets/stylesheets/commontator/threads.css~

@@ -1,71 +0,0 @@
-.thread {
-  display: block !important;
-}
-
-.thread_actions {
-  float: right;
-}
-
-.thread_header {
-  font-size: 16px;
-  font-weight: bold;
-  font-style: normal;
-  margin-top: 5px;
-  margin-bottom: 5px;
-  display: block;
-}
-
-.thread_new_comment {
-  display: none;
-}
-
-.thread_new_comment_link {
-  display: block;
-}
-
-/* Modified from:
-http://www.strangerstudios.com/sandbox/pagination/diggstyle.php */
-.thread_page_entries_info {
-	margin-top: 10px;
-  margin-bottom: 10px;
-}
-
-.thread_will_paginate {
-	margin-top: 10px;
-  margin-bottom: 10px;
-}
-
-.thread_pagination a {
-	padding: 2px 5px 2px 5px;
-	margin-right: 4px;
-	border: 1px solid #999;
-	
-	text-decoration: none;
-	color: #666;
-}
-
-.thread_pagination a:hover,
-.thread_pagination a:active {
-	border: 1px solid #555;
-
-	color: #000;
-}
-
-.thread_pagination em {
-	padding: 2px 5px 2px 5px;
-	margin-right: 4px;
-  border: 1px solid #555;
-
-  font-weight: bold;
-  background-color: #555;
-  color: #FFF;
-}
-
-.thread_pagination span {
-  padding: 2px 5px 2px 5px;
-  margin: 2px;
-  border: 1px solid #EEE;
-
-  color: #DDD;
-}
-

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

@@ -1,35 +0,0 @@
-module Commontator
-  class ApplicationController < ActionController::Base
-    cattr_reader :app_routes
-
-    before_filter :get_user, :ensure_user, :set_app_routes
-    
-    rescue_from SecurityTransgression, :with => lambda { head(:forbidden) }
-    
-    protected
-
-    def security_transgression_unless(check)
-      raise SecurityTransgression unless check
-    end
-
-    def get_user
-      @user = Commontator.current_user_proc.call(self)
-    end
-
-    def ensure_user
-      security_transgression_unless(@user && @user.is_commontator)
-    end
-
-    def get_thread
-      @thread = params[:thread_id].blank? ? \
-        Commontator::Thread.find(params[:id]) : \
-        Commontator::Thread.find(params[:thread_id])
-      security_transgression_unless @thread.can_be_read_by? @user
-    end
-
-    def set_app_routes
-      @@app_routes = main_app
-    end
-  end
-end
-

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

@@ -1,153 +0,0 @@
-module Commontator
-  class CommentsController < Commontator::ApplicationController
-    before_filter :get_thread, :only => [:new, :create]
-    before_filter :get_comment_and_thread, :except => [:new, :create]
-
-    # GET /threads/1/comments/new
-    def new
-      @comment = Comment.new
-      @comment.thread = @thread
-      @comment.creator = @user
-
-      security_transgression_unless @comment.can_be_created_by?(@user)
-
-      @per_page = params[:per_page] || thread.config.comments_per_page
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js
-      end
-     
-    end
-
-    # POST /threads/1/comments
-    def create
-      @comment = Comment.new
-      @comment.body = params[:comment].nil? ? nil : params[:comment][:body]
-      @comment.thread = @thread
-      @comment.creator = @user
-      
-      security_transgression_unless @comment.can_be_created_by?(@user)
-      
-      respond_to do |format|
-        if  !params[:cancel].nil?
-          format.html { redirect_to @thread }
-          format.js { render :cancel }
-        elsif @comment.save
-          sub = @thread.config.thread_subscription.to_sym
-          @thread.subscribe(@user) if sub == :a || sub == :b
-          Subscription.comment_created(@comment)
-
-          @per_page = params[:per_page] || @thread.config.comments_per_page
-
-          format.html { redirect_to @thread }
-          format.js
-        else
-          format.html { redirect_to @thread }
-          format.js { render :new }
-        end
-      end
-    end
-
-    # GET /comments/1/edit
-    def edit
-      security_transgression_unless @comment.can_be_edited_by?(@user)
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js
-      end
-    end
-
-    # PUT /comments/1
-    def update
-      security_transgression_unless @comment.can_be_edited_by?(@user)
-      @comment.body = params[:comment].nil? ? nil : params[:comment][:body]
-      @comment.editor = @user
-
-      respond_to do |format|
-        if !params[:cancel].nil?
-          format.html { redirect_to @thread }
-          format.js { render :cancel }
-        elsif @comment.save
-          format.html { redirect_to @thread }
-          format.js
-        else
-          format.html { redirect_to @thread }
-          format.js { render :edit }
-        end
-      end
-    end
-
-    # PUT /comments/1/delete
-    def delete
-      security_transgression_unless @comment.can_be_deleted_by?(@user)
-
-      @comment.errors.add(:base, t('commontator.comment.errors.already_deleted')) \
-        unless @comment.delete_by(@user)
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :delete }
-      end
-    end
-    
-    # PUT /comments/1/undelete
-    def undelete
-      security_transgression_unless @comment.can_be_deleted_by?(@user)
-
-      @comment.errors.add(:base, t('commontator.comment.errors.not_deleted')) \
-        unless @comment.undelete_by(@user)
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :delete }
-      end
-    end
-    
-    # PUT /comments/1/upvote
-    def upvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user)
-      
-      @comment.upvote_from @user
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
-    end
-    
-    # PUT /comments/1/downvote
-    def downvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user) &&\
-        @comment.thread.config.comment_voting.to_sym == :ld
-      
-      @comment.downvote_from @user
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
-    end
-    
-    # PUT /comments/1/unvote
-    def unvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user)
-      
-      @comment.unvote :voter => @user
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
-    end
-    
-    protected
-    
-    def get_comment_and_thread
-      @comment = Comment.find(params[:id])
-      @thread = @comment.thread
-    end
-  end
-end
-

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

@@ -1,44 +0,0 @@
-module Commontator
-  class SubscriptionsMailer < ActionMailer::Base
-    def comment_created(comment, recipients)
-      setup_variables(comment, recipients)
-
-      mail :to => @to,
-           :bcc => @bcc,
-           :from => @from,
-           :subject => t('commontator.email.comment_created.subject',
-                         :creator_name => @creator_name,
-                         :commontable_name => @commontable_name,
-                         :commontable_url => @commontable_url)
-    end
-
-    protected
-
-    def setup_variables(comment, recipients)
-      @comment = comment
-      @thread = @comment.thread
-      @creator = @comment.creator
-
-      @creator_name = Commontator.commontator_name(@creator)
-
-      @commontable_name = Commontator.commontable_name(@thread)
-
-      @commontable_url = Commontator.commontable_url(@thread)
-
-      params = Hash.new
-      params[:comment] = @comment
-      params[:thread] = @thread
-      params[:creator] = @creator
-      params[:creator_name] = @creator_name
-      params[:commontable_name] = @commontable_name
-      params[:commontable_url] = @commontable_url
-
-      @to = t('commontator.email.undisclosed_recipients')
-      @bcc = recipients.collect{|s| Commontator.commontator_email(s, self)}
-      @from = @config.email_from_proc.call(@thread)
-    end
-
-    
-  end
-end
-

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

@@ -1,119 +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
-
-    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 => I18n.t('commontator.comment.errors.double_posted')
-
-    protected
-
-    cattr_accessor :acts_as_votable_initialized
-
-    public
-
-    def is_modified?
-      !editor.nil?
-    end
-
-    def is_latest?
-      thread.comments.last == self
-    end
-
-    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? && user && user.is_commontator
-      votes.where(:voter_type => user.class.name, :voter_id => user.id).first
-    end
-
-    def update_cached_votes(vote_scope = nil)
-      self.update_column(:cached_votes_up, count_votes_up(true)
-      self.update_column(:cached_votes_down, count_votes_down(true)
-    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 created_timestamp
-      I18n.t 'commontator.comment.status.created_at',
-             :created_at => I18n.l(created_at, :format => :commontator)
-    end
-    
-    def updated_timestamp
-      I18n.t 'commontator.comment.status.updated_at',
-             :editor_name => Commontator.commontator_name(editor || creator),
-             :updated_at => I18n.l(updated_at, :format => :commontator)
-    end
-
-    ##################
-    # Access Control #
-    ##################
-
-    def can_be_created_by?(user)
-      user == creator && user.is_commontator &&\
-      !thread.is_closed? && thread.can_be_read_by?(user)
-    end
-
-    def can_be_edited_by?(user)
-      return true if thread.can_be_edited_by?(user) &&\
-                     thread.config.moderator_permissions.to_sym == :e
-      comment_edit = thread.config.comment_editing.to_sym
-      !thread.is_closed? && !is_deleted? && user == creator &&\
-      comment_edit != :n && (is_latest? || comment_edit == :a) &&\
-      thread.can_be_read_by?(user)
-    end
-
-    def can_be_deleted_by?(user)
-      mod_perm = thread.config.moderator_permissions.to_sym
-      return true if thread.can_be_edited_by?(user) &&\
-                     (mod_perm == :e ||\
-                       mod_perm == :d)
-      comment_del = thread.config.comment_deletion.to_sym
-      !thread.is_closed? && (!is_deleted? || editor == user) &&\
-      user == creator && comment_del != :n &&\
-      (is_latest? || comment_del == :a) &&\
-      thread.can_be_read_by?(user)
-    end
-
-    def can_be_voted_on?
-      !thread.is_closed? && !is_deleted? &&\
-      thread.config.comment_voting.to_sym != :n && is_votable?
-    end
-
-    def can_be_voted_on_by?(user)
-      !user.nil? && user.is_commontator && user != creator &&\
-      thread.can_be_read_by?(user) && can_be_voted_on?
-    end
-  end
-end
-

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

@@ -1,159 +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
-      @config ||= commontable.try(:commontable_config) || Commontator
-    end
-
-    def will_paginate?
-      return false if config.comments_per_page.nil? || !comments.respond_to?(:paginate)
-      require 'commontator/link_renderer'
-      true
-    end
-
-    def is_filtered?
-      will_paginate? || config.comment_filter
-    end
-
-    def filtered_comments
-      cf = config.comment_filter
-      return comments if cf.nil?
-      comments.where(cf)
-    end
-
-    def ordered_comments(override = false)
-      vc = override ? comments : filtered_comments
-      case config.comment_order.to_sym
-      when :l then vc.order('id DESC')
-      when :ve then vc.order('cached_votes_down - cached_votes_up')
-      when :vl then vc.order('cached_votes_down - cached_votes_up', 'id DESC')
-      else vc
-      end
-    end
-
-    def paginated_comments(page = 1, per_page = config.comments_per_page)
-      oc = ordered_comments
-      return oc unless will_paginate?
-      oc.paginate(:page => page, :per_page => per_page)
-    end
-
-    def new_comment_page(per_page = config.comments_per_page)
-      return 1 if per_page.nil? || per_page.to_i <= 0
-      comment_index = \
-        case config.comment_order.to_sym
-        when :l
-          1 # First comment
-        when :ve
-          comment_arel = Comment.arel_table
-          # Last comment with rating = 0
-          filtered_comments.where((comment_arel[:cached_votes_up] - comment_arel[:cached_votes_down]).gteq 0).count
-        when :vl
-          comment_arel = Comment.arel_table
-          # First comment with rating = 0
-          filtered_comments.where((comment_arel[:cached_votes_up] - comment_arel[:cached_votes_down]).gt 0).count + 1
-        else
-          filtered_comments.count # Last comment
-        end
-      (comment_index.to_f/per_page.to_i).ceil
-    end
-
-    def is_closed?
-      !closed_at.blank?
-    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
-
-    def subscribers
-      subscriptions.collect{|s| s.subscriber}
-    end
-
-    def subscription_for(subscriber)
-      return nil if !subscriber || !subscriber.is_commontator
-      subscriber.subscriptions.where(:thread_id => self.id).first
-    end
-
-    def subscribe(subscriber)
-      return false unless subscriber.is_commontator && !subscription_for(subscriber)
-      subscription = Subscription.new
-      subscription.subscriber = subscriber
-      subscription.thread = self
-      subscription.save
-    end
-
-    def unsubscribe(subscriber)
-      subscription = subscription_for(subscriber)
-      return false unless subscription
-      subscription.destroy
-    end
-
-    def mark_as_read_for(subscriber)
-      subscription = subscription_for(subscriber)
-      return false unless subscription
-      subscription.touch
-    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
-      return if commontable.blank? || !is_closed?
-      new_thread = Thread.new
-      new_thread.commontable = commontable
-
-      with_lock do
-        self.commontable = nil
-        save!
-        new_thread.save!
-        subscriptions.each do |s|
-          s.thread = new_thread
-          s.save!
-        end
-      end
-    end
-
-    ##################
-    # Access Control #
-    ##################
-
-    # Reader capabilities (user can be nil or false)
-    def can_be_read_by?(user)
-      return true if can_be_edited_by?(user)
-      !commontable.nil? &&\
-      config.thread_read_proc.call(self, user)
-    end
-
-    # Thread moderator capabilities
-    def can_be_edited_by?(user)
-      !commontable.nil? && !user.nil? && user.is_commontator &&\
-      config.thread_moderator_proc.call(self, user)
-    end
-
-    def can_subscribe?(user)
-      thread_sub = config.thread_subscription.to_sym
-      !is_closed? && !user.nil? && user.is_commontator &&\
-      (thread_sub == :m || thread_sub == :b) &&\
-      can_be_read_by?(user)
-    end
-  end
-end
-