publify_core 9.0.0.pre5 → 9.2.0

data/app/models/content.rb

@@ -1,39 +1,40 @@
-require 'set'
-require 'uri'
+# frozen_string_literal: true
 
-class Content < ActiveRecord::Base
-  include Stateful
+require "set"
+require "uri"
 
+class Content < ApplicationRecord
   include ContentBase
 
-  # TODO: Move these calls to ContentBase
-  after_save :invalidates_cache?
-  after_destroy ->(c) { c.invalidates_cache?(true) }
-
-  belongs_to :text_filter, optional: true
-  belongs_to :user, optional: true
+  belongs_to :user, optional: true, touch: true
   belongs_to :blog
 
   validates :blog, presence: true
 
-  has_one :redirect, dependent: :destroy, inverse_of: :contents
+  has_one :redirect, dependent: :destroy, inverse_of: :content
 
   has_many :triggers, as: :pending_item, dependent: :delete_all
-
-  scope :user_id, ->(user_id) { where('user_id = ?', user_id) }
-  scope :published, -> { where(published: true, published_at: Time.at(0)..Time.now).order('published_at DESC') }
-  scope :published_at, ->(time_params) { published.where(published_at: PublifyTime.delta(*time_params)).order('published_at DESC') }
-  scope :not_published, -> { where('published = ?', false) }
-  scope :draft, -> { where('state = ?', 'draft') }
-  scope :no_draft, -> { where('state <> ?', 'draft').order('published_at DESC') }
+  has_many :resources, inverse_of: :content, dependent: :nullify
+  has_and_belongs_to_many :tags
+
+  scope :user_id, ->(user_id) { where("user_id = ?", user_id) }
+  scope :published, -> { where(state: "published").order(default_order) }
+  scope :published_at, lambda { |time_params|
+                         published.where(published_at: PublifyTime.delta(*time_params))
+                       }
+  scope :not_published, -> { where.not(state: "published") }
+  scope :drafts, -> { where(state: "draft").order("created_at DESC") }
+  scope :no_draft, -> { where.not(state: "draft").order("published_at DESC") }
   scope :searchstring, lambda { |search_string|
-    tokens = search_string.split(' ').map { |c| "%#{c.downcase}%" }
-    where('state = ? AND ' + (['(LOWER(body) LIKE ? OR LOWER(extended) LIKE ? OR LOWER(title) LIKE ?)'] * tokens.size).join(' AND '),
-          'published', *tokens.map { |token| [token] * 3 }.flatten)
+    tokens = search_string.split(" ").map { |c| "%#{c.downcase}%" }
+    matcher = "(LOWER(body) LIKE ? OR LOWER(extended) LIKE ? OR LOWER(title) LIKE ?)"
+    template = "state = ? AND #{([matcher] * tokens.size).join(" AND ")}"
+    where(template, "published", *tokens.map { |token| [token] * 3 }.flatten)
   }
-  scope :already_published, -> { where('published = ? AND published_at < ?', true, Time.now).order(default_order) }
 
-  scope :published_at_like, ->(date_at) { where(published_at: PublifyTime.delta_like(date_at)) }
+  scope :published_at_like, lambda { |date_at|
+                              where(published_at: PublifyTime.delta_like(date_at))
+                            }
 
   serialize :whiteboard
 
@@ -46,28 +47,20 @@ class Content < ActiveRecord::Base
     end
   end
 
-  # Set the text filter for this object.
-  # NOTE: Due to how Rails injects association methods, this cannot be put in ContentBase
-  # TODO: Allowing assignment of a string here is not very clean.
-  def text_filter=(filter)
-    filter_object = case filter
-                    when TextFilter
-                      filter
-                    else
-                      TextFilter.find_or_default(filter)
-                    end
-    self.text_filter_id = if filter_object
-                            filter_object.id
-                          else
-                            filter.to_i
-                          end
+  def author_name
+    if user.present? && user.name.present?
+      user.name
+    else
+      author
+    end
   end
 
   def shorten_url
-    return unless published
+    return unless published?
 
     if redirect.present?
       return if redirect.to_path == permalink_url
+
       redirect.to_path = permalink_url
       redirect.save
     else
@@ -78,16 +71,15 @@ class Content < ActiveRecord::Base
     end
   end
 
-  def self.find_already_published(_limit)
-    where('published_at < ?', Time.now).limit(1000).order('created_at DESC')
+  # TODO: Inline this method
+  def self.find_already_published(limit)
+    published.limit(limit)
   end
 
   def self.search_with(params)
     params ||= {}
     scoped = unscoped
-    if params[:searchstring].present?
-      scoped = scoped.searchstring(params[:searchstring])
-    end
+    scoped = scoped.searchstring(params[:searchstring]) if params[:searchstring].present?
 
     if params[:published_at].present? && /(\d\d\d\d)-(\d\d)/ =~ params[:published_at]
       scoped = scoped.published_at_like(params[:published_at])
@@ -98,8 +90,8 @@ class Content < ActiveRecord::Base
     end
 
     if params[:published].present?
-      scoped = scoped.published if params[:published].to_s == '1'
-      scoped = scoped.not_published if params[:published].to_s == '0'
+      scoped = scoped.published if params[:published].to_s == "1"
+      scoped = scoped.not_published if params[:published].to_s == "0"
     end
 
     scoped
@@ -109,30 +101,18 @@ class Content < ActiveRecord::Base
     self[:whiteboard] ||= {}
   end
 
-  def withdraw!
-    withdraw
-    save!
-  end
-
-  def link_to_author?
-    !user.email.blank? && blog.link_to_author
-  end
-
-  def get_rss_description
-    return '' unless blog.rss_description
-    return '' unless respond_to?(:user) && user && user.name
+  def rss_description
+    return "" unless blog.rss_description
 
     rss_desc = blog.rss_description_text
-    rss_desc.gsub!('%author%', user.name)
-    rss_desc.gsub!('%blog_url%', blog.base_url)
-    rss_desc.gsub!('%blog_name%', blog.blog_name)
-    rss_desc.gsub!('%permalink_url%', permalink_url)
+    rss_desc.gsub!("%author%", author_name)
+    rss_desc.gsub!("%blog_url%", blog.base_url)
+    rss_desc.gsub!("%blog_name%", blog.blog_name)
+    rss_desc.gsub!("%permalink_url%", permalink_url)
     rss_desc
   end
 
   def short_url
-    # Double check because of crappy data in my own old database
-    return unless published && redirect.present?
-    redirect.from_url
+    redirect.from_url if redirect.present?
   end
 end

data/app/models/content_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ContentBase
   def self.included(base)
     base.extend ClassMethods
@@ -52,7 +54,7 @@ module ContentBase
   end
 
   def excerpt_text(length = 160)
-    text = if respond_to?(:excerpt) && (excerpt || '') != ''
+    text = if respond_to?(:excerpt) && (excerpt || "") != ""
              generate_html(:excerpt, excerpt)
            else
              html(:all)
@@ -61,20 +63,11 @@ module ContentBase
     text = text.strip_html
 
     text.slice(0, length) +
-      (text.length > length ? '...' : '')
-  end
-
-  def invalidates_cache?(on_destruction = false)
-    @invalidates_cache ||= if on_destruction
-                             just_changed_published_status? || published?
-                           else
-                             (changed? && published?) || just_changed_published_status?
-                           end
+      (text.length > length ? "..." : "")
   end
 
-  def publish!
-    self.published = true
-    save!
+  def text_filter
+    TextFilter.make_filter(text_filter_name)
   end
 
   # The default text filter.  Generally, this is the filter specified by blog.text_filter,
@@ -89,7 +82,7 @@ module ContentBase
     end
 
     def default_order
-      'published_at DESC'
+      "published_at DESC"
     end
   end
 end

data/app/models/feedback.rb

@@ -1,16 +1,15 @@
-require_dependency 'spam_protection'
-require 'akismet'
+# frozen_string_literal: true
 
-class Feedback < ActiveRecord::Base
-  self.table_name = 'feedback'
+require "aasm"
+require "akismet"
 
-  belongs_to :text_filter, optional: true
-  belongs_to :article
+class Feedback < ApplicationRecord
+  self.table_name = "feedback"
+
+  belongs_to :article, touch: true
 
   include PublifyGuid
-  include Stateful
   include ContentBase
-  include States
 
   class ContentTextHelpers
     include ActionView::Helpers::UrlHelper
@@ -21,54 +20,71 @@ class Feedback < ActiveRecord::Base
   validate :feedback_not_closed, on: :create
   validates :article, presence: true
 
+  before_save :correct_url, :classify_content
   before_create :create_guid, :article_allows_this_feedback
-  before_save :correct_url, :before_save_handler
-  after_save :post_trigger, :report_classification, :invalidates_cache?
-  after_initialize :after_initialize_handler
-  after_destroy ->(c) { c.invalidates_cache?(true) }
 
+  # TODO: Rename so it doesn't sound like only approved ham
   scope :ham, -> { where(state: %w(presumed_ham ham)) }
-  scope :spam, -> { where(state: 'spam') }
-  scope :published_since, ->(time) { ham.where('published_at > ?', time) }
-  scope :presumed_ham, -> { where(state: 'presumed_ham') }
-  scope :presumed_spam, -> { where(state: 'presumed_spam') }
-  scope :unapproved, -> { where(status_confirmed: false) }
 
-  scope :published, -> { where(published: true) }
+  scope :spam, -> { where(state: "spam") }
+  scope :created_since, ->(time) { ham.where("created_at > ?", time) }
+  scope :presumed_ham, -> { where(state: "presumed_ham") }
+  scope :presumed_spam, -> { where(state: "presumed_spam") }
+  scope :unapproved, -> { where(state: ["presumed_spam", "presumed_ham"]) }
+
+  scope :published, -> { ham }
   scope :oldest_first, -> { order(:created_at) }
+  scope :newest_first, -> { order(created_at: :desc) }
 
-  has_state(:state,
-            valid_states: [:unclassified, :presumed_spam, :just_marked_as_spam, :spam, :just_presumed_ham, :presumed_ham, :just_marked_as_ham, :ham],
-            handles: [:published?, :status_confirmed?, :just_published?,
-                      :mark_as_ham, :mark_as_spam, :confirm_classification,
-                      :withdraw,
-                      :before_save_handler, :after_initialize_handler,
-                      :send_notifications, :post_trigger, :report_classification])
+  include AASM
 
-  def self.paginated(page, per_page)
-    page(page).per(per_page)
-  end
+  aasm column: :state do
+    state :unclassified, initial: true
+    state :presumed_ham
+    state :presumed_spam
+    state :spam, after_enter: [:send_notifications, :report_as_spam]
+    state :ham, after_enter: [:send_notifications, :report_as_ham]
 
-  def self.comments
-    Comment.where(published: true).order('created_at DESC')
-  end
+    event :presume_ham do
+      transitions from: :unclassified, to: :ham, if: ->() { user_id.present? }
+      transitions from: :unclassified, to: :presumed_ham
+    end
 
-  def self.trackbacks
-    Trackback.where(published: true).order('created_at DESC')
-  end
+    event :presume_spam do
+      transitions from: :unclassified, to: :presumed_spam
+    end
 
-  def self.from(type, article_id = nil)
-    if article_id.present?
-      Article.find(article_id).send("published_#{type}")
-    else
-      send(type)
+    event :mark_as_ham do
+      transitions to: :ham
+    end
+
+    event :mark_as_spam do
+      transitions to: :spam
     end
+
+    event :withdraw do
+      transitions from: [:presumed_ham, :ham], to: :spam
+    end
+  end
+
+  # FIXME: Inline this method
+  def self.paginated(page, per_page)
+    page(page).per(per_page)
   end
 
   def parent
     article
   end
 
+  def classify_content
+    return unless unclassified?
+
+    case classify
+    when :ham then presume_ham
+    else presume_spam
+    end
+  end
+
   def permalink_url(_anchor = :ignored, only_path = false)
     article.permalink_url("#{self.class.to_s.downcase}-#{id}", only_path)
   end
@@ -80,7 +96,8 @@ class Feedback < ActiveRecord::Base
 
   def correct_url
     return if url.blank?
-    self.url = 'http://' + url.to_s unless url =~ %r{^https?://}
+
+    self.url = "http://#{url}" unless %r{^https?://}.match?(url)
   end
 
   def article_allows_this_feedback
@@ -140,30 +157,33 @@ class Feedback < ActiveRecord::Base
   end
 
   def change_state!
-    result = ''
-    if state.spam? || state.presumed_spam?
-      mark_as_ham
-      result = 'ham'
+    result = ""
+    if spam? || presumed_spam?
+      mark_as_ham!
+      result = "ham"
     else
-      mark_as_spam
-      result = 'spam'
+      mark_as_spam!
+      result = "spam"
     end
-    save!
     result
   end
 
-  def mark_as_ham!
-    mark_as_ham
+  def confirm_classification!
+    confirm_classification
     save!
   end
 
-  def mark_as_spam!
-    mark_as_spam
-    save!
+  def confirm_classification
+    if presumed_spam?
+      mark_as_spam
+    elsif presumed_ham?
+      mark_as_ham
+    end
   end
 
   def report_as_spam
     return if akismet.nil?
+
     begin
       Timeout.timeout(5) do
         akismet.submit_spam(ip, user_agent, akismet_options)
@@ -175,6 +195,7 @@ class Feedback < ActiveRecord::Base
 
   def report_as_ham
     return if akismet.nil?
+
     begin
       Timeout.timeout(5) do
         akismet.ham(ip, user_agent, akismet_options)
@@ -184,36 +205,40 @@ class Feedback < ActiveRecord::Base
     end
   end
 
-  def withdraw!
-    withdraw
-    save!
+  def feedback_not_closed
+    errors.add(:article_id, "Comment are closed") if article.comments_closed?
   end
 
-  def confirm_classification!
-    confirm_classification
-    save
+  def send_notifications
+    nil
   end
 
-  def feedback_not_closed
-    errors.add(:article_id, 'Comment are closed') if article.comments_closed?
+  def published?
+    ham? || presumed_ham?
+  end
+
+  def status_confirmed?
+    ham? || spam?
+  end
+
+  def spammy?
+    spam? || presumed_spam?
   end
 
   delegate :blog, to: :article
 
   private
 
-  @@akismet = nil
-
   def akismet
-    @@akismet = akismet_client if @@akismet.nil?
-    @@akismet == false ? nil : @@akismet
+    @akismet ||= akismet_client
   end
 
   def akismet_client
-    return false if blog.sp_akismet_key.blank?
+    return nil if blog.sp_akismet_key.blank?
+
     client = Akismet::Client.new(blog.sp_akismet_key, blog.base_url)
     begin
-      return client.verify_key ? client : false
+      client.verify_key ? client : nil
     rescue SocketError
       nil
     end