fuck_comments 2.3.4

data/app/controllers/concerns/the_comments/view_token.rb

@@ -0,0 +1,20 @@
+module TheComments
+  # Cookies and View token for spam protection
+  # include TheComments::ViewToken
+  module ViewToken
+    extend ActiveSupport::Concern
+
+    included { before_action :set_the_comments_cookies }
+
+    def comments_view_token
+      cookies[:comments_view_token]
+    end
+
+    private
+
+    def set_the_comments_cookies
+      cookies[:the_comment_cookies] = { value: TheComments::COMMENTS_COOKIES_TOKEN, expires: 1.year.from_now, domain: TheComments.config.cookie_domain }
+      cookies[:comments_view_token] = { value: SecureRandom.hex, expires: 7.days.from_now, domain: TheComments.config.cookie_domain } unless cookies[:comments_view_token]
+    end
+  end
+end

data/app/helpers/render_comments_tree_helper.rb

@@ -0,0 +1,111 @@
+# coding: UTF-8
+# DOC:
+# We use Helper Methods for tree building,
+# because it's faster than View Templates and Partials
+
+# SECURITY note
+# Prepare your data on server side for rendering
+# or use h.html_escape(node.content)
+# for escape potentially dangerous content
+module RenderCommentsTreeHelper
+  module Render 
+    class << self
+      attr_accessor :h, :options
+
+      # Main Helpers
+      def controller
+        @options[:controller]
+      end
+
+      def t str
+        controller.t str
+      end
+
+      # Render Helpers
+      def visible_draft?
+        controller.try(:comments_view_token) == @comment.view_token
+      end
+
+      def moderator?
+        controller.try(:current_user).try(:comments_moderator?, @comment)
+      end
+
+      # Render Methods
+      def render_node(h, options)
+        @h, @options = h, options
+        @comment     = options[:node]
+
+        @max_reply_depth = options[:max_reply_depth] || TheComments.config.max_reply_depth
+
+        if @comment.draft?
+          draft_comment
+        else @comment.published?
+          published_comment
+        end
+      end
+
+      def draft_comment
+        if visible_draft? || moderator?
+          published_comment
+        else
+          "<li class='draft'>
+            <div class='comment draft' id='comment_#{@comment.anchor}'>
+              #{ t('the_comments.waiting_for_moderation') }
+              #{ h.link_to '#', '#comment_' + @comment.anchor }
+            </div>
+            #{ children }
+          </li>"
+        end
+      end
+
+      def published_comment
+        "<li>
+          <div id='comment_#{@comment.anchor}' class='comment #{@comment.state}' data-comment-id='#{@comment.to_param}'>
+            <div>
+              #{ avatar }
+              #{ userbar }
+              <div class='cbody'>#{ @comment.content }</div>
+              #{ reply }
+            </div>
+          </div>
+
+          <div class='form_holder'></div>
+          #{ children }
+        </li>"
+      end
+
+      def avatar
+        "<div class='userpic'>
+          <img src='#{ @comment.avatar_url }' alt='userpic' />
+          #{ controls }
+        </div>"
+      end
+
+      def userbar
+        anchor = h.link_to('#', '#comment_' + @comment.anchor)
+        title  = @comment.title.blank? ? t('the_comments.guest_name') : @comment.title
+        "<div class='userbar'>#{ title } #{ anchor }</div>"
+      end
+
+      def moderator_controls
+        if moderator?
+          h.link_to(t('the_comments.edit'), h.edit_comment_url(@comment), class: :edit)
+        end
+      end
+
+      def reply
+        if @comment.depth < (@max_reply_depth - 1)
+          "<p class='reply'><a href='#' class='reply_link'>#{ t('the_comments.reply') }</a>"
+        end
+      end
+
+      def controls
+        "<div class='controls'>#{ moderator_controls }</div>"
+      end
+
+      def children
+        "<ol class='nested_set'>#{ options[:children] }</ol>"
+      end
+    end
+  end
+end

data/app/models/_templates_/comment.rb

@@ -0,0 +1,38 @@
+class Comment < ActiveRecord::Base
+  include TheComments::Comment
+  # ---------------------------------------------------
+  # Define comment's avatar url
+  # Usually we use Comment#user (owner of comment) to define avatar
+  # @blog.comments.includes(:user) <= use includes(:user) to decrease queries count
+  # comment#user.avatar_url
+  # ---------------------------------------------------
+
+  # public
+  # ---------------------------------------------------
+  # Simple way to define avatar url
+  #
+  # def avatar_url
+  #   src = id.to_s
+  #   src = title unless title.blank?
+  #   src = contacts if !contacts.blank? && /@/ =~ contacts
+  #   hash = Digest::MD5.hexdigest(src)
+  #   "https://2.gravatar.com/avatar/#{hash}?s=42&d=https://identicons.github.com/#{hash}.png"
+  # end
+  # ---------------------------------------------------
+
+  # private
+  # ---------------------------------------------------
+  # Define your content filters
+  # gem 'RedCloth'
+  # gem 'sanitize'
+  # gem 'MySmilesProcessor'
+  #
+  # def prepare_content
+  #   text = self.raw_content
+  #   text = RedCloth.new(text).to_html
+  #   text = MySmilesProcessor.new(text)
+  #   text = Sanitize.clean(text, Sanitize::Config::RELAXED)
+  #   self.content = text
+  # end
+  # ---------------------------------------------------
+end

data/app/models/concerns/the_comments/comment.rb

@@ -0,0 +1,116 @@
+module TheComments
+  module Comment
+    extend ActiveSupport::Concern
+
+    included do
+      scope :active, -> { with_state [:draft, :published] }
+      scope :with_users, -> { includes(:user) }
+
+      # Nested Set
+      acts_as_nested_set scope: [:commentable_type, :commentable_id]
+
+      # simple sort scopes
+      include ::TheSimpleSort::Base
+
+      # TheSortableTree
+      include ::TheSortableTree::Scopes
+
+      # Comments State Machine
+      include TheComments::CommentStates
+
+      validates :raw_content, presence: true
+
+      # relations
+      belongs_to :user
+      belongs_to :holder, class_name: :User
+      belongs_to :commentable, polymorphic: true
+
+      # callbacks
+      before_create :define_holder, :define_default_state, :define_anchor, :denormalize_commentable
+      after_create  :update_cache_counters
+      before_save   :prepare_content
+    end
+
+    def header_title
+      title.present? ? title : I18n.t('the_comments.guest_name')
+    end
+
+    def user_name
+      user.try(:username) || user.try(:login) || header_title
+    end
+
+    def avatar_url
+      src = id.to_s
+      src = title unless title.blank?
+      src = contacts if !contacts.blank? && /@/ =~ contacts
+      hash = Digest::MD5.hexdigest(src)
+      "https://2.gravatar.com/avatar/#{hash}?s=42&d=https://identicons.github.com/#{hash}.png"
+    end
+
+    def mark_as_spam
+      count = self_and_descendants.update_all({spam: true})
+      update_spam_counter
+      count
+    end
+
+    def mark_as_not_spam
+      count = self_and_descendants.update_all({spam: false})
+      update_spam_counter
+      count
+    end
+
+    def to_spam
+      mark_as_spam
+    end
+
+    private
+
+    def update_spam_counter
+      holder.try :update_comcoms_spam_counter
+    end
+
+    def define_anchor
+      self.anchor = SecureRandom.hex[0..5]
+    end
+
+    def define_holder
+      c = self.commentable
+      self.holder = c.is_a?(User) ? c : c.try(:user)
+    end
+
+    def define_default_state
+      self.state = TheComments.config.default_owner_state if user && user == holder
+    end
+
+    def denormalize_commentable
+      self.commentable_title = commentable.try :commentable_title
+      self.commentable_state = commentable.try :commentable_state
+      self.commentable_url   = commentable.try :commentable_url
+    end
+
+    def prepare_content
+      self.content = self.raw_content
+    end
+
+    # Warn: increment! doesn't call validation =>
+    # before_validation filters doesn't work   =>
+    # We have few unuseful requests
+    # I impressed that I found it and reduce DB requests
+    # Awesome logic pazzl! I'm really pedant :D
+    def update_cache_counters
+      user.try :recalculate_my_comments_counter!
+
+      if holder
+        holder.send :try, :define_denormalize_flags
+        holder.increment! "#{ state }_comcoms_count"
+        # holder.class.increment_counter("#{ state }_comcoms_count", holder.id)
+      end
+
+      if commentable
+        commentable.send :define_denormalize_flags
+        commentable.increment! "#{ state }_comments_count"
+        # holder.class.increment_counter("#{ state }_comments_count", holder.id)
+      end
+    end
+  end
+end

data/app/models/concerns/the_comments/comment_states.rb

@@ -0,0 +1,80 @@
+module TheComments
+  module CommentStates
+    extend ActiveSupport::Concern
+
+    included do
+      # :draft | :published | :deleted
+      state_machine :state, :initial => TheComments.config.default_state do
+
+        # events
+        event :to_draft do
+          transition all - :draft => :draft
+        end
+
+        event :to_published do
+          transition all - :published => :published
+        end
+
+        event :to_deleted do
+          transition any - :deleted => :deleted
+        end
+
+        # transition callbacks
+        after_transition any => any do |comment|
+          @comment     = comment
+          @owner       = comment.user
+          @holder      = comment.holder
+          @commentable = comment.commentable
+        end
+
+        # between draft and published
+        after_transition [:draft, :published] => [:draft, :published] do |comment, transition|
+          from = transition.from_name
+          to   = transition.to_name
+
+          if @holder
+            @holder.send :try, :define_denormalize_flags
+            @holder.increment! "#{to}_comcoms_count"
+            @holder.decrement! "#{from}_comcoms_count"
+          end
+
+          if @commentable
+            @commentable.send       :define_denormalize_flags
+            @commentable.increment! "#{to}_comments_count"
+            @commentable.decrement! "#{from}_comments_count"
+          end
+        end
+
+        # to deleted (cascade like query)
+        after_transition [:draft, :published] => :deleted do |comment|
+          ids = comment.self_and_descendants.map(&:id)
+          ::Comment.where(id: ids).update_all(state: :deleted)
+
+          @owner.try       :recalculate_my_comments_counter!
+          @holder.try      :recalculate_comcoms_counters!
+          @commentable.try :recalculate_comments_counters!
+        end
+
+        # from deleted
+        after_transition :deleted => [:draft, :published] do |comment, transition|
+          to = transition.to_name
+          comment.mark_as_not_spam
+
+          @owner.try :recalculate_my_comments_counter!
+
+          if @holder
+            @holder.send :try, :define_denormalize_flags
+            @holder.decrement! :deleted_comcoms_count
+            @holder.increment! "#{to}_comcoms_count"
+          end
+
+          if @commentable
+            @commentable.send       :define_denormalize_flags
+            @commentable.decrement! :deleted_comments_count
+            @commentable.increment! "#{to}_comments_count"
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/the_comments/commentable.rb

@@ -0,0 +1,69 @@
+module TheComments
+  module Commentable
+
+    extend ActiveSupport::Concern
+    
+    included do
+      has_many :comments, as: :commentable
+
+      # *define_denormalize_flags* - should be placed before title or url builder filters
+      before_validation :define_denormalize_flags
+      after_save        :denormalize_for_comments, if: -> { !id_changed? }
+    end
+
+    # Default Denormalization methods
+    # Overwrite it with your Application
+    def commentable_title
+      # My first blog post
+      try(:title) || TheComments.config.default_title
+    end
+
+    def commentable_url
+      # /posts/1
+      ['', self.class.to_s.tableize, self.to_param].join('/')
+    end
+
+    def commentable_state
+      # 'draft'
+      try(:state)
+    end
+
+    # Helper methods
+    def comments_sum
+      published_comments_count + draft_comments_count
+    end
+
+    def recalculate_comments_counters!
+      update_attributes!({
+        draft_comments_count:     comments.with_state(:draft).count,
+        published_comments_count: comments.with_state(:published).count,
+        deleted_comments_count:   comments.with_state(:deleted).count
+      })
+    end
+
+    private
+
+    def define_denormalize_flags
+      @trackable_commentable_title = commentable_title
+      @trackable_commentable_state = commentable_state
+      @trackable_commentable_url   = commentable_url
+    end
+
+    def denormalization_fields_changed?
+      a = @trackable_commentable_title != commentable_title
+      b = @trackable_commentable_state != commentable_state
+      c = @trackable_commentable_url   != commentable_url
+      a || b || c
+    end
+
+    def denormalize_for_comments
+      if denormalization_fields_changed?
+        comments.update_all({
+          commentable_title: commentable_title,
+          commentable_state: commentable_state,
+          commentable_url:   commentable_url
+        })
+      end 
+    end
+  end
+end

data/app/models/concerns/the_comments/user.rb

@@ -0,0 +1,56 @@
+module TheComments
+  module User
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :comcoms, class_name: :Comment, foreign_key: :holder_id
+    end
+
+    def my_comments; ::Comment.where(user: self); end
+
+    %w[draft published deleted].each do |state|
+      define_method "my_#{state}_comments" do
+        my_comments.with_state state
+      end
+
+      define_method "#{state}_comcoms" do
+        comcoms.with_state state
+      end
+    end
+
+    def my_spam_comments
+      my_comments.where(spam: true)
+    end
+
+    # I think we shouldn't to have my_deleted_comments cache counter
+    def recalculate_my_comments_counter!
+      dcount = my_draft_comments.count
+      pcount = my_published_comments.count
+      update_attributes!({
+        my_draft_comments_count:     dcount,
+        my_published_comments_count: pcount,
+        my_comments_count:           dcount + pcount
+      })
+    end
+
+    def recalculate_comcoms_counters!
+      update_attributes!({
+        draft_comcoms_count:     draft_comcoms.count,
+        published_comcoms_count: published_comcoms.count,
+        deleted_comcoms_count:   deleted_comcoms.count
+      })
+    end
+
+    def update_comcoms_spam_counter
+      update!(spam_comcoms_count: comcoms.where(spam: true).count)
+    end
+
+    def comments_sum
+      published_comments_count + draft_comments_count
+    end
+
+    def comcoms_sum
+      published_comcoms_count + draft_comcoms_count
+    end
+  end
+end