commontator 5.1.0 → 6.0.0.pre.1

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

@@ -1,75 +0,0 @@
-module Commontator
-  class ThreadsController < Commontator::ApplicationController
-    skip_before_filter :ensure_user, :only => :show
-    before_filter :set_thread
-
-    # GET /threads/1
-    def show
-      commontator_thread_show(@thread.commontable)
-      @show_all = params[:show_all] && @thread.can_be_edited_by?(@user)
-
-      respond_to do |format|
-        format.html { redirect_to main_app.polymorphic_path(@thread.commontable) }
-        format.js
-      end
-    end
-
-    # GET /threads/1/hide
-    def hide
-      respond_to do |format|
-        format.js
-      end
-    end
-    
-    # PUT /threads/1/close
-    def close
-      security_transgression_unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, t('commontator.thread.errors.already_closed')) \
-        unless @thread.close(@user)
-
-      @show_all = true
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
-      end
-    end
-    
-    # PUT /threads/1/reopen
-    def reopen
-      security_transgression_unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, t('commontator.thread.errors.not_closed')) \
-        unless @thread.reopen
-
-      @show_all = true
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
-      end
-    end
-
-    # GET /threads/1/mentions.json
-    def mentions
-      security_transgression_unless @thread.can_be_read_by?(@user) && Commontator.mentions_enabled
-      query = params[:q].to_s
-
-      if query.size < 3
-        render json: { errors: ['Query string is too short (minimum 3 characters)'] },
-               status: :unprocessable_entity
-      else
-        render json: serialized_mentions(query)
-      end
-    end
-
-    protected
-
-    def serialized_mentions(query)
-      { mentions: Commontator.commontator_mentions(@user, query).map do |user|
-        { id: user.id, name: Commontator.commontator_name(user), type: 'user' }
-      end }
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module Commontator
-  class SubscriptionsMailer < ActionMailer::Base
-    def comment_created(comment, recipients)
-      setup_variables(comment, recipients)
-      message = mail :to => @to,
-                     :bcc => @bcc,
-                     :from => @from,
-                     :subject => t('commontator.email.comment_created.subject',
-                                   :creator_name => @creator_name,
-                                   :commontable_name => @commontable_name,
-                                   :comment_url => @comment_url)
-
-      message.mailgun_recipient_variables = mailgun_recipient_variables(recipients) if uses_mailgun?
-    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)
-
-<<<<<<< Updated upstream
-      @commontable_url = Commontator.commontable_url(@comment, main_app)
-=======
-      @comment_url = Commontator.comment_url(@comment, main_app)
->>>>>>> Stashed changes
-
-      params = Hash.new
-      params[:comment] = @comment
-      params[:thread] = @thread
-      params[:creator] = @creator
-      params[:creator_name] = @creator_name
-      params[:commontable_name] = @commontable_name
-      params[:comment_url] = @comment_url
-
-      if uses_mailgun?
-        @to = recipient_emails(recipients)
-      else
-        @to = t('commontator.email.undisclosed_recipients')
-        @bcc = recipient_emails(recipients)
-      end
-
-      @from = @thread.config.email_from_proc.call(@thread)
-    end
-
-    def recipient_emails(recipients)
-      recipients.collect{ |s| Commontator.commontator_email(s, self) }
-    end
-
-    def mailgun_recipient_variables(recipients)
-      recipient_emails(recipients).each_with_object({}) do |user_email, memo|
-        memo[user_email] = {}
-      end
-    end
-
-    def uses_mailgun?
-      Rails.application.config.action_mailer.delivery_method == :mailgun
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-module Commontator
-  class Comment < ActiveRecord::Base
-    belongs_to :creator, :polymorphic => true
-    belongs_to :editor, :polymorphic => true
-    belongs_to :thread
-    belongs_to :parent_comment
-
-    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, :deleted_at],
-      :message => I18n.t('commontator.comment.errors.double_posted')
-
-    validate :parent_comment_in_same_thread
-
-    protected
-
-    cattr_accessor :acts_as_votable_initialized
-
-    def parent_comment_in_same_thread
-      return if parent_comment.nil? || parent_comment.thread_id == thread_id
-      errors.add(:parent_comment, 'must belong to the same thread')
-    end
-
-    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.nil? && user.is_commontator
-      votes_for.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.nil? && 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/subscription.rb~

@@ -1,23 +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 self.comment_created(comment)
-      recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
-      return if recipients.empty?
-
-      mail = SubscriptionsMailer.comment_created(comment, recipients)
-      (mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver) \
-        unless recipients.empty?
-    end
-
-    def unread_comments
-      created_at = Comment.arel_table[:created_at]
-      thread.filtered_comments.where(created_at.gt(updated_at))
-    end
-  end
-end

data/app/views/commontator/shared/_thread.html.erb~

@@ -1,21 +0,0 @@
-<% # Clients of this partial must supply the following variables:
-   # thread
-   # user
-%>
-
-<% if !thread.can_be_read_by?(user) %>
-  <div id="thread_<%= thread.id %>_div" class="thread" style="display: none;">
-    <% if @commontator_thread_show %>
-      <%= render :partial => 'commontator/threads/show',
-                 :locals => { :thread => thread,
-                              :user => user,
-                              :page => @commontator_page,
-                              :per_page => @commontator_per_page } %>
-    <% else %>
-      <% subscription = thread.subscription_for(user) %>
-      <%= link_to "#{t 'commontator.thread.actions.show'} (#{(subscription.unread_comments.count.to_s + '/') if subscription}#{thread.filtered_comments.count.to_s})",
-                  commontator.thread_path(thread),
-                  :remote => true %>
-    <% end %>
-  </div>
-<% end %>

data/app/views/commontator/subscriptions_mailer/comment_created.html.erb~

@@ -1,10 +0,0 @@
-<h4><%= t 'commontator.email.comment_created.body',
-          :creator_name => @creator_name,
-          :commontable_name => @commontable_name %></h4>
-
-<%= render :partial => 'commontator/comments/body',
-           :locals => { :comment => @comment } %>
-
-<p><%= t 'commontator.email.thread_link_html',
-         :comment_url => @commontable_url,
-         :commontable_name => @commontable_name %></p>

data/app/views/commontator/threads/_hide_show.js.erb~

@@ -1,21 +0,0 @@
-$("#").replaceWith(<%= ej(
-  link_to t('commontator.thread.actions.show'),
-          '#',
-          :id => "thread_#{thread.id.to_s}_show_link",
-          :class => "thread_show_link",
-          :remote => true
-) %>);
-
-$().replaceWith(<%= ej(
-  link_to t('commontator.thread.actions.hide'),
-          '#',
-          :id => "thread_#{thread.id.to_s}_hide_link",
-          :class => "thread_hide_link",
-          :remote => true
-) %>);
-
-      <%= link_to t('commontator.thread.actions.hide'),
-                  '',
-                  :id => "thread_#{thread.id.to_s}_hide_link",
-                  :class => "thread_hide_link",
-                  :remote => true %>

data/app/views/commontator/threads/_hide_show_links.js.erb~

@@ -1,17 +0,0 @@
-<% # Clients of this partial must supply the following variables:
-   # thread
-%>
-
-$("#thread_<%= thread.id %>_hide_link").click(function() {
-  $("#thread_<%= thread.id %>_span").hide();
-
-  $("#thread_<%= thread.id %>_show_span").fadeIn()[0].scrollIntoView();
-});
-
-$("#thread_<%= thread.id %>_show_link").click(function() {
-  $("#thread_<%= thread.id %>_span").fadeIn()[0].scrollIntoView();
-
-  $("#thread_<%= thread.id %>_span").hide();
-});
-
-$("#thread_<%= thread.id %>_hide_span").show();

data/app/views/commontator/threads/_show.html.erb~

@@ -1,118 +0,0 @@
-<% # Clients of this partial must supply the following variables:
-   # thread
-   # user
-   # page
-   # per_page
-   # Optionally, they can also supply the following variable:
-   show_all ||= false
-%>
-
-<% can_subscribe = thread.can_subscribe?(user)
-   can_edit = thread.can_be_edited_by?(user) %>
-
-<span id="thread_<%= thread.id.to_s %>_show_span" class="thread_show commontator_hidden">
-  <%= link_to t('commontator.thread.actions.show'),
-              '#',
-              id: "thread_#{thread.id.to_s}_show_link",
-              class: "thread_show_link" %>
-</span>
-
-<span id="thread_<%= thread.id %>_span" class="thread_span">
-  <span id="thread_<%= thread.id.to_s %>_actions_span" class="thread_actions">
-    <span id="thread_<%= thread.id.to_s %>_hide_span" class="thread_hide commontator_hidden">
-      <%= link_to t('commontator.thread.actions.hide'),
-                  '#',
-                  id: "thread_#{thread.id.to_s}_hide_link",
-                  class: "thread_hide_link" %>
-    </span>
-
-    &nbsp;
-
-    <% if can_subscribe %>
-      <span id="thread_<%= thread.id.to_s %>_subscription_span" class="thread_subscription">
-        <%= render :partial => 'commontator/subscriptions/link',
-                   :locals => { :thread => thread,
-                                :user => user } %>
-      </span>
-    <% end %>
-
-    &nbsp;
-
-    <% if can_edit %>
-      <% filter_string = show_all ? 'filter' : 'show_all'
-         is_closed = thread.is_closed?
-         close_string = is_closed ? 'reopen' : 'close' %>
-
-      <% if thread.is_filtered? %>
-        <%= link_to t("commontator.thread.actions.#{filter_string}"),
-                    commontator.thread_path(thread, :show_all => (show_all ? nil : true)),
-                    :id => "thread_#{thread.id.to_s}_#{filter_string}_link",
-                    :class => "thread_#{filter_string}_link",
-                    :remote => true %>
-
-        &nbsp;
-      <% end %>
-
-      <%= link_to t("commontator.thread.actions.#{close_string}"),
-                  commontator.polymorphic_path([close_string, thread]),
-                  :confirm => (!is_closed ? t('commontator.thread.actions.confirm_close') : nil),
-                  :method => :put,
-                  :id => "thread_#{thread.id.to_s}_#{close_string}_link",
-                  :class => "thread_#{close_string}_link",
-                  :remote => true %>
-    <% end %>
-  </span>
-
-  <span id="thread_<%= thread.id.to_s %>_header_span" class="thread_header">
-    <%= t "commontator.thread.status.#{thread.is_closed? ? 'closed' : 'open'}",
-          :closer_name => (thread.is_closed? ? Commontator.commontator_name(thread.closer) : '') %>
-  </span>
-
-  <% if thread.config.comment_order == :l %>
-    <%= render :partial => 'commontator/threads/reply',
-               :locals => { :thread => thread, :user => user, :per_page => per_page } %>
-  <% end %>
-
-  <div id="thread_<%= thread.id.to_s %>_comment_list_div" class="thread_comment_list">
-    <% comments = show_all ? thread.ordered_comments(true) : \
-                             thread.paginated_comments(page, per_page) %>
-    <%= render :partial => 'commontator/comments/list',
-               :locals => { :comments => comments,
-                            :user => user } %>
-  </div>
-
-  <% if thread.will_paginate? && !show_all %>
-    <div id="thread_<%= thread.id.to_s %>_pagination_div" class="thread_pagination">
-      <div id="thread_<%= thread.id.to_s %>_page_entries_info_div" class="thread_page_entries_info">
-        <%= page_entries_info comments,
-                              :params => { :controller => 'commontator/threads',
-                                           :action => 'show',
-                                           :id => thread.id,
-                                           :page => page,
-                                           :per_page => per_page } %>.
-      </div>
-
-      <div id="thread_<%= thread.id.to_s %>_will_paginate_div" class="thread_will_paginate">
-        <%= will_paginate comments,
-                          :renderer => Commontator::LinkRenderer,
-                          :routes_proxy => commontator,
-                          :remote => true,
-                          :params => { :controller => 'commontator/threads',
-                                       :action => 'show',
-                                       :id => thread.id,
-                                       :page => page,
-                                       :per_page => per_page } %>
-      </div>
-    </div>
-  <% end %>
-
-  <% if thread.config.comment_order != :l %>
-    <%= render :partial => 'commontator/threads/reply',
-               :locals => { :thread => thread, :user => user, :per_page => per_page } %>
-  <% end %>
-</span>
-
-<script type="text/javascript">
-  <%= j(render partial: 'commontator/threads/hide_show_links.js',
-               locals: { thread: thread }) %>
-</script>