publify_core 9.0.0.pre1

data/app/models/comment.rb

@@ -0,0 +1,53 @@
+require_dependency 'spam_protection'
+require 'timeout'
+
+class Comment < Feedback
+  belongs_to :user
+  content_fields :body
+  validates :author, :body, presence: true
+
+  after_save :send_notifications
+
+  attr_accessor :referrer, :permalink
+
+  scope :spam, -> { where(state: 'spam') }
+  scope :not_spam, -> { where("state != 'spam'") }
+  scope :presumed_spam, -> { where(state: 'presumed_spam') }
+  scope :presumed_ham, -> { where(state: 'presumed_ham') }
+  scope :ham, -> { where(state: 'ham') }
+  scope :unconfirmed, -> { where(state: %w(presumed_spam presumed_ham)) }
+
+  scope :last_published, -> { published.limit(5).order('created_at DESC') }
+
+  def notify_user_via_email(user)
+    EmailNotify.send_comment(self, user) if user.notify_via_email?
+  end
+
+  def interested_users
+    User.where(notify_on_comments: true)
+  end
+
+  def default_text_filter
+    TextFilter.find_or_default(blog.comment_text_filter)
+  end
+
+  def feed_title
+    "Comment on #{article.title} by #{author}"
+  end
+
+  protected
+
+  def article_allows_feedback?
+    return true if article.allow_comments?
+    errors.add(:article, 'Article is not open to comments')
+    false
+  end
+
+  def originator
+    author
+  end
+
+  def content_fields
+    [:body]
+  end
+end

data/app/models/config_manager.rb

@@ -0,0 +1,81 @@
+module ConfigManager
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def fields
+      @fields ||= Hash.new { Item.new }
+    end
+
+    def setting(name, type = :object, default = nil)
+      item = Item.new
+      item.name = name.to_s
+      item.ruby_type = type
+      item.default = default
+      fields[name.to_s] = item
+      add_setting_accessor(item)
+    end
+
+    def default_for(key)
+      fields[key.to_s].default
+    end
+
+    private
+
+    def add_setting_accessor(item)
+      add_setting_reader(item)
+      add_setting_writer(item)
+    end
+
+    def add_setting_reader(item)
+      send(:define_method, item.name) do
+        raw_value = settings[item.name]
+        raw_value.nil? ? item.default : raw_value
+      end
+      if item.ruby_type == :boolean
+        send(:define_method, item.name + '?') do
+          raw_value = settings[item.name]
+          raw_value.nil? ? item.default : raw_value
+        end
+      end
+    end
+
+    def add_setting_writer(item)
+      send(:define_method, "#{item.name}=") do |newvalue|
+        self.settings ||= {}
+        retval = settings[item.name] = canonicalize(item.name, newvalue)
+        retval
+      end
+    end
+  end
+
+  def canonicalize(key, value)
+    self.class.fields[key.to_s].canonicalize(value)
+  end
+
+  class Item
+    attr_accessor :name, :ruby_type, :default
+
+    def canonicalize(value)
+      case ruby_type
+      when :boolean
+        case value
+        when '0', 0, '', false, 'false', 'f', nil
+          false
+        else
+          true
+        end
+      when :integer
+        value.to_i
+      when :string
+        value.to_s
+      when :yaml
+        value.to_yaml
+      else
+        value
+      end
+    end
+  end
+end

data/app/models/content.rb

@@ -0,0 +1,138 @@
+require 'set'
+require 'uri'
+
+class Content < ActiveRecord::Base
+  include Stateful
+
+  include ContentBase
+
+  # TODO: Move these calls to ContentBase
+  after_save :invalidates_cache?
+  after_destroy ->(c) { c.invalidates_cache?(true) }
+
+  belongs_to :text_filter
+  belongs_to :user
+  belongs_to :blog
+
+  validates :blog, presence: true
+
+  has_one :redirect, dependent: :destroy
+
+  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') }
+  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)
+  }
+  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)) }
+
+  serialize :whiteboard
+
+  def author=(user)
+    if user.respond_to?(:login)
+      self[:author] = user.login
+      self.user = user
+    elsif user.is_a?(String)
+      self[:author] = user
+    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
+  end
+
+  def shorten_url
+    return unless published
+
+    if redirect.present?
+      return if redirect.to_path == permalink_url
+      redirect.to_path = permalink_url
+      redirect.save
+    else
+      r = Redirect.new(blog: blog)
+      r.from_path = r.shorten
+      r.to_path = permalink_url
+      self.redirect = r
+    end
+  end
+
+  def self.find_already_published(_limit)
+    where('published_at < ?', Time.now).limit(1000).order('created_at DESC')
+  end
+
+  def self.search_with(params)
+    params ||= {}
+    scoped = unscoped
+    if params[:searchstring].present?
+      scoped = scoped.searchstring(params[:searchstring])
+    end
+
+    if params[:published_at].present? && /(\d\d\d\d)-(\d\d)/ =~ params[:published_at]
+      scoped = scoped.published_at_like(params[:published_at])
+    end
+
+    if params[:user_id].present? && params[:user_id].to_i > 0
+      scoped = scoped.user_id(params[:user_id])
+    end
+
+    if params[:published].present?
+      scoped = scoped.published if params[:published].to_s == '1'
+      scoped = scoped.not_published if params[:published].to_s == '0'
+    end
+
+    scoped
+  end
+
+  def whiteboard
+    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
+
+    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
+  end
+
+  def short_url
+    # Double check because of crappy data in my own old database
+    return unless published && redirect.present?
+    redirect.from_url
+  end
+end

data/app/models/content_base.rb

@@ -0,0 +1,95 @@
+module ContentBase
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  attr_accessor :just_changed_published_status
+  alias just_changed_published_status? just_changed_published_status
+
+  def really_send_notifications
+    interested_users.each do |value|
+      send_notification_to_user(value)
+    end
+    true
+  end
+
+  def send_notification_to_user(user)
+    notify_user_via_email(user)
+  end
+
+  # Return HTML for some part of this object.
+  def html(field = :all)
+    if field == :all
+      generate_html(:all, content_fields.map { |f| self[f].to_s }.join("\n\n"))
+    elsif html_map(field)
+      generate_html(field)
+    else
+      raise "Unknown field: #{field.inspect} in content.html"
+    end
+  end
+
+  # Generate HTML for a specific field using the text_filter in use for this
+  # object.
+  def generate_html(field, text = nil)
+    text ||= self[field].to_s
+    prehtml = html_preprocess(field, text).to_s
+    html = (text_filter || default_text_filter).filter_text(prehtml) || prehtml
+    html_postprocess(field, html).to_s
+  end
+
+  # Post-process the HTML.  This is a noop by default, but Comment overrides it
+  # to enforce HTML sanity.
+  def html_postprocess(_field, html)
+    html
+  end
+
+  def html_preprocess(_field, html)
+    html
+  end
+
+  def html_map(field)
+    content_fields.include? field
+  end
+
+  def excerpt_text(length = 160)
+    text = if respond_to?(:excerpt) && (excerpt || '') != ''
+             generate_html(:excerpt, excerpt)
+           else
+             html(:all)
+           end
+
+    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
+  end
+
+  def publish!
+    self.published = true
+    save!
+  end
+
+  # The default text filter.  Generally, this is the filter specified by blog.text_filter,
+  # but comments may use a different default.
+  def default_text_filter
+    blog.text_filter_object
+  end
+
+  module ClassMethods
+    def content_fields(*attribs)
+      class_eval "def content_fields; #{attribs.inspect}; end"
+    end
+
+    def default_order
+      'published_at DESC'
+    end
+  end
+end

data/app/models/feedback/states.rb

@@ -0,0 +1,256 @@
+module Feedback::States
+  class Base < Stateful::State
+    # Give the default 'model' a more meaningful name
+    alias content model
+
+    # Callback handlers
+    def before_save_handler
+      true
+    end
+
+    def after_initialize_handler
+      true
+    end
+
+    def post_trigger
+      true
+    end
+
+    def send_notifications
+      true
+    end
+
+    def report_classification
+      true
+    end
+
+    def withdraw; end
+
+    def confirm_classification; end
+
+    def mark_as_spam
+      content.state = :just_marked_as_spam
+    end
+
+    def mark_as_ham
+      content.state = :just_marked_as_ham
+    end
+  end
+
+  class Unclassified < Base
+    def after_initialize_handler
+      enter_hook
+      true
+    end
+
+    def enter_hook
+      super
+      content[:published] = false
+      content[:status_confirmed] = false
+    end
+
+    def published?
+      classify_content
+      content.published?
+    end
+
+    def just_published?
+      classify_content
+      content.just_published?
+    end
+
+    def spam?
+      classify_content
+      content.spam?
+    end
+
+    def classify_content
+      content.state = case content.classify
+                      when :ham then :just_presumed_ham
+                      when :spam then :presumed_spam
+                      else :presumed_spam
+                      end
+    end
+
+    def before_save_handler
+      classify_content
+    end
+
+    def to_s
+      'unclassified'
+    end
+  end
+
+  class JustPresumedHam < Base
+    def enter_hook
+      super
+      content.just_changed_published_status = true
+      content.state = :presumed_ham unless content.user_id
+      content.state = :just_marked_as_ham if content.user_id
+    end
+
+    def to_s
+      'just_presumed_ham'
+    end
+  end
+
+  class PresumedHam < Base
+    def enter_hook
+      super
+      content[:published] = true
+      content[:status_confirmed] = false
+    end
+
+    def published?
+      true
+    end
+
+    def just_published?
+      content.just_changed_published_status?
+    end
+
+    def withdraw
+      mark_as_spam
+    end
+
+    def confirm_classification
+      mark_as_ham
+    end
+
+    def mark_as_ham
+      content.state = :ham
+    end
+
+    def to_s
+      'presumed_ham'
+    end
+
+    def send_notifications
+      content.really_send_notifications if content.just_changed_published_status
+      true
+    end
+  end
+
+  class JustMarkedAsHam < Base
+    def enter_hook
+      super
+      content.just_changed_published_status = true
+      content.state = :ham
+    end
+
+    def to_s
+      'just_marked_as_ham'
+    end
+  end
+
+  class Ham < Base
+    def enter_hook
+      super
+      content[:published] = true
+      content[:status_confirmed] = true
+    end
+
+    def published?
+      true
+    end
+
+    def status_confirmed?
+      true
+    end
+
+    def mark_as_ham; end
+
+    def just_published?
+      content.just_changed_published_status?
+    end
+
+    def withdraw
+      mark_as_spam
+    end
+
+    def report_classification
+      content.report_as_ham if content.just_changed_published_status?
+      true
+    end
+
+    def send_notifications
+      content.really_send_notifications if content.just_changed_published_status?
+      true
+    end
+
+    def to_s
+      'ham'
+    end
+  end
+
+  class PresumedSpam < Base
+    def enter_hook
+      super
+      content[:published] = false
+      content[:status_confirmed] = false
+    end
+
+    def spam?
+      true
+    end
+
+    def mark_as_ham
+      content.state = :just_marked_as_ham
+    end
+
+    def mark_as_spam
+      content.state = :spam
+    end
+
+    def withdraw
+      mark_as_spam
+    end
+
+    def confirm_classification
+      mark_as_spam
+    end
+
+    def to_s
+      'presumed_spam'
+    end
+  end
+
+  class JustMarkedAsSpam < Base
+    def enter_hook
+      super
+      content.just_changed_published_status = true
+      content.state = :spam
+    end
+
+    def to_s
+      'just_marked_as_spam'
+    end
+  end
+
+  class Spam < Base
+    def enter_hook
+      super
+      content[:published] = false
+      content[:status_confirmed] = true
+    end
+
+    def spam?
+      true
+    end
+
+    def status_confirmed?
+      true
+    end
+
+    def mark_as_spam; end
+
+    def report_classification
+      content.report_as_spam if content.just_changed_published_status?
+      true
+    end
+
+    def to_s
+      'spam'
+    end
+  end
+end