publify_core 9.0.0.pre6 → 9.0.0

data/app/models/feedback.rb

@@ -1,16 +1,16 @@
-require_dependency 'spam_protection'
+# frozen_string_literal: true
+
+require 'aasm'
 require 'akismet'
 
 class Feedback < ActiveRecord::Base
   self.table_name = 'feedback'
 
   belongs_to :text_filter, optional: true
-  belongs_to :article
+  belongs_to :article, touch: true
 
   include PublifyGuid
-  include Stateful
   include ContentBase
-  include States
 
   class ContentTextHelpers
     include ActionView::Helpers::UrlHelper
@@ -22,52 +22,69 @@ class Feedback < ActiveRecord::Base
   validates :article, presence: true
 
   before_create :create_guid, :article_allows_this_feedback
-  before_save :correct_url, :before_save_handler
-  after_save :post_trigger, :report_classification
-  after_initialize :after_initialize_handler
+  before_save :correct_url, :classify_content
 
+  # 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 :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(status_confirmed: false) }
+  scope :unapproved, -> { where(state: ['presumed_spam', 'presumed_ham']) }
 
-  scope :published, -> { where(published: true) }
+  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
 
+  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
@@ -140,25 +157,27 @@ class Feedback < ActiveRecord::Base
 
   def change_state!
     result = ''
-    if state.spam? || state.presumed_spam?
-      mark_as_ham
+    if spam? || presumed_spam?
+      mark_as_ham!
       result = 'ham'
     else
-      mark_as_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
@@ -183,36 +202,39 @@ 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
+      return client.verify_key ? client : nil
     rescue SocketError
       nil
     end

data/app/models/meta_sidebar.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 class MetaSidebar < Sidebar
   description "This widget just displays links to Publify main site, this blog's admin and RSS."
 

data/app/models/note.rb

@@ -18,6 +18,9 @@ class Note < Content
   after_create :set_permalink, :shorten_url
   before_create :create_guid
 
+  scope :published, lambda {
+    where(state: 'published').where('published_at <= ?', Time.zone.now).order(default_order)
+  }
   default_scope { order('published_at DESC') }
 
   TWITTER_FTP_URL_LENGTH = 19
@@ -123,6 +126,10 @@ class Note < Content
     blog.shortener_url.sub(/^https?\:\/\//, '')
   end
 
+  def published?
+    state == 'published'
+  end
+
   private
 
   def too_long?(message)

data/app/models/page.rb

@@ -17,11 +17,7 @@ class Page < Content
   content_fields :body
 
   def self.default_order
-    'name ASC'
-  end
-
-  def self.search_with(search_hash)
-    super(search_hash).order('title ASC')
+    'title ASC'
   end
 
   def permalink_url(anchor = nil, only_path = false)
@@ -33,4 +29,13 @@ class Page < Content
       only_path: only_path
     )
   end
+
+  def publish!
+    self.state = 'published'
+    save!
+  end
+
+  def published?
+    state == 'published'
+  end
 end

data/app/models/ping.rb

@@ -1,116 +1,3 @@
-require 'rexml/document'
-require 'xmlrpc/client'
-
 class Ping < ActiveRecord::Base
   belongs_to :article
-
-  class Pinger
-    attr_accessor :article
-    attr_accessor :blog
-
-    def send_pingback_or_trackback
-      @response = Net::HTTP.get_response(URI.parse(ping.url))
-      send_pingback or send_trackback
-    rescue Timeout::Error
-      Rails.logger.info 'Sending pingback or trackback timed out'
-      return
-    rescue => err
-      Rails.logger.info "Sending pingback or trackback failed with error: #{err}"
-    end
-
-    def pingback_url
-      if response['X-Pingback']
-        response['X-Pingback']
-      elsif response.body =~ /<link rel="pingback" href="([^"]+)" ?\/?>/
-        Regexp.last_match[1]
-      end
-    end
-
-    attr_reader :origin_url
-
-    attr_reader :response
-
-    attr_reader :ping
-
-    def send_xml_rpc(*args)
-      ping.send(:send_xml_rpc, *args)
-    end
-
-    def trackback_url
-      rdfs = response.body.scan(/<rdf:RDF.*?<\/rdf:RDF>/m)
-      rdfs.each do |rdf|
-        xml = REXML::Document.new(rdf)
-        xml.elements.each('//rdf:Description') do |desc|
-          if rdfs.size == 1 || desc.attributes['dc:identifier'] == ping.url
-            return desc.attributes['trackback:ping']
-          end
-        end
-      end
-      # Didn't find a trackback url, so fall back to the url itself.
-      @ping.url
-    end
-
-    def send_pingback
-      if pingback_url
-        send_xml_rpc(pingback_url, 'pingback.ping', origin_url, ping.url)
-        true
-      else
-        false
-      end
-    end
-
-    def send_trackback
-      do_send_trackback(trackback_url, origin_url)
-    end
-
-    def do_send_trackback(trackback_url, origin_url)
-      trackback_uri = URI.parse(trackback_url)
-
-      post = "title=#{CGI.escape(article.title)}"
-      post << "&excerpt=#{CGI.escape(article.html(:body).strip_html[0..254])}"
-      post << "&url=#{origin_url}"
-      post << "&blog_name=#{CGI.escape(blog.blog_name)}"
-
-      path = trackback_uri.path
-      path += "?#{trackback_uri.query}" if trackback_uri.query
-
-      Net::HTTP.start(trackback_uri.host, trackback_uri.port) do |http|
-        http.post(path, post, 'Content-type' => 'application/x-www-form-urlencoded; charset=utf-8')
-      end
-    end
-
-    private
-
-    def initialize(origin_url, ping)
-      @origin_url = origin_url
-      @ping = ping
-      # Add this call to text filter cause of a strange thing around text_filter. Need to clean text_filter usage !
-      ping.article.default_text_filter
-      ping.article.text_filter
-      # Make sure these are fetched now for thread safety purposes.
-      self.article = ping.article
-      self.blog = article.blog
-    end
-  end
-
-  def send_pingback_or_trackback(origin_url)
-    t = Thread.start(Pinger.new(origin_url, self), &:send_pingback_or_trackback)
-    t
-  end
-
-  def send_weblogupdatesping(server_url, origin_url)
-    t = Thread.start(article.blog.blog_name) do |blog_name|
-      send_xml_rpc(url, 'weblogUpdates.ping', blog_name, server_url, origin_url)
-    end
-    t
-  end
-
-  protected
-
-  def send_xml_rpc(xml_rpc_url, name, *args)
-    server = XMLRPC::Client.new2(URI.parse(xml_rpc_url).to_s)
-    server.call(name, *args)
-  rescue => e
-    logger.error(e)
-  end
 end

data/app/models/post_type.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 class PostType < ActiveRecord::Base
   validates :name, uniqueness: true
   validates :name, presence: true

data/app/models/redirect.rb

@@ -1,5 +1,5 @@
 class Redirect < ActiveRecord::Base
-  belongs_to :contents, optional: true
+  belongs_to :contents, optional: true, touch: true
   belongs_to :blog
 
   validates :from_path, uniqueness: true

data/app/models/resource.rb

@@ -3,26 +3,8 @@ require 'carrierwave/orm/activerecord'
 
 class Resource < ActiveRecord::Base
   belongs_to :blog
-  belongs_to :article, optional: true
+  belongs_to :content, optional: true
 
   mount_uploader :upload, ResourceUploader
-  validate :image_mime_type_consistent
   validates :upload, presence: true
-
-  scope :without_images, -> { where("mime NOT LIKE '%image%'") }
-  scope :images, -> { where("mime LIKE '%image%'") }
-  scope :by_filename, -> { order('upload') }
-  scope :by_created_at, -> { order('created_at DESC') }
-
-  scope :without_images_by_filename, -> { without_images.by_filename }
-  scope :images_by_created_at, -> { images.by_created_at }
-
-  private
-
-  def image_mime_type_consistent
-    if upload.content_type =~ %r{^image/}
-      expected_type = upload.file.send :mime_magic_content_type
-      errors.add(:upload, 'Has MIME type mismatch') unless upload.content_type == expected_type
-    end
-  end
 end

data/app/models/sidebar.rb

@@ -125,7 +125,7 @@ class Sidebar < ActiveRecord::Base
 
   def to_locals_hash
     fields.reduce(sidebar: self) do |hash, field|
-      hash.merge(field.key => config[field.key])
+      hash.merge(field.key => field.current_value(self))
     end
   end
 

data/app/models/static_sidebar.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 class StaticSidebar < Sidebar
   DEFAULT_TEXT = '
 <ul>

data/app/models/tag.rb

@@ -1,6 +1,6 @@
 class Tag < ActiveRecord::Base
   belongs_to :blog
-  has_and_belongs_to_many :articles, order: 'created_at DESC', join_table: 'articles_tags'
+  has_and_belongs_to_many :contents, order: 'created_at DESC'
 
   validates :name, uniqueness: { scope: :blog_id }
   validates :blog, presence: true
@@ -30,15 +30,15 @@ class Tag < ActiveRecord::Base
 
   def ensure_naming_conventions
     self.display_name = name if display_name.blank?
-    self.name = display_name.to_url unless display_name.blank?
+    self.name = display_name.to_url if display_name.present?
   end
 
-  def self.find_all_with_article_counters
-    Tag.joins(:articles).
-      where(contents: { published: true }).
-      select(*Tag.column_names, 'COUNT(articles_tags.article_id) as article_counter').
+  def self.find_all_with_content_counters
+    Tag.joins(:contents).
+      where(contents: { state: 'published' }).
+      select(*Tag.column_names, 'COUNT(contents_tags.content_id) as content_counter').
       group(*Tag.column_names).
-      order('article_counter DESC').limit(1000)
+      order('content_counter DESC').limit(1000)
   end
 
   def self.find_with_char(char)
@@ -49,14 +49,18 @@ class Tag < ActiveRecord::Base
     tags.map(&:display_name).sort.map { |name| name =~ / / ? "\"#{name}\"" : name }.join ', '
   end
 
-  def published_articles
-    articles.already_published
+  def published_contents
+    contents.published
   end
 
   def permalink
     name
   end
 
+  def feed_url(format)
+    "#{permalink_url}.#{format.gsub(/\d/, '')}"
+  end
+
   def permalink_url(_anchor = nil, only_path = false)
     blog.url_for(controller: 'tags', action: 'show', id: permalink, only_path: only_path)
   end