HornsAndHooves-publify_core 10.0.0

data/app/models/config_manager.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+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,118 @@
+# frozen_string_literal: true
+
+require "set"
+require "uri"
+
+class Content < ApplicationRecord
+  include ContentBase
+
+  belongs_to :user, optional: true, touch: true
+  belongs_to :blog
+
+  validates :blog, presence: true
+
+  has_one :redirect, dependent: :destroy, inverse_of: :content
+
+  has_many :triggers, as: :pending_item, dependent: :delete_all
+  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}%" }
+    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 :published_at_like, lambda { |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
+
+  def author_name
+    if user.present? && user.name.present?
+      user.name
+    else
+      author
+    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
+
+  # TODO: Inline this method
+  def self.find_already_published(limit)
+    published.limit(limit)
+  end
+
+  def self.search_with(params)
+    params ||= {}
+    scoped = unscoped
+    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])
+    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 rss_description
+    return "" unless blog.rss_description
+
+    rss_desc = blog.rss_description_text
+    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
+    redirect.from_url if redirect.present?
+  end
+end

data/app/models/content_base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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 text_filter
+    TextFilter.make_filter(text_filter_name)
+  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.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "aasm"
+require "akismet"
+
+class Feedback < ApplicationRecord
+  self.table_name = "feedback"
+
+  belongs_to :article, touch: true
+
+  include PublifyGuid
+  include ContentBase
+
+  class ContentTextHelpers
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::SanitizeHelper
+  end
+
+  validate :feedback_not_closed, on: :create
+  validates :article, presence: true
+
+  before_create :create_guid, :article_allows_this_feedback
+  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 :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) }
+
+  include AASM
+
+  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]
+
+    event :presume_ham do
+      transitions from: :unclassified, to: :ham, if: ->() { user_id.present? }
+      transitions from: :unclassified, to: :presumed_ham
+    end
+
+    event :presume_spam do
+      transitions from: :unclassified, to: :presumed_spam
+    end
+
+    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
+
+  def html_postprocess(_field, html)
+    helper = ContentTextHelpers.new
+    helper.sanitize(helper.auto_link(html))
+  end
+
+  def correct_url
+    return if url.blank?
+
+    self.url = "http://" + url.to_s unless %r{^https?://}.match?(url)
+  end
+
+  def article_allows_this_feedback
+    article && blog_allows_feedback? && article_allows_feedback?
+  end
+
+  def blog_allows_feedback?
+    true
+  end
+
+  def akismet_options
+    { type: self.class.to_s.downcase,
+      author: originator,
+      author_email: email,
+      author_url: url,
+      text: body }
+  end
+
+  def spam_fields
+    [:title, :body, :ip, :url]
+  end
+
+  def classify
+    return :ham if user_id
+    return :spam if blog.default_moderate_comments
+    return :ham unless blog.sp_global
+
+    # Yeah, three state logic is evil...
+    case sp_is_spam? || akismet_is_spam?
+    when nil then :spam
+    when true then :spam
+    when false then :ham
+    end
+  end
+
+  def sp_is_spam?(_options = {})
+    sp = SpamProtection.new(blog)
+    Timeout.timeout(30) do
+      spam_fields.any? do |field|
+        sp.is_spam?(send(field))
+      end
+    end
+  rescue Timeout::Error
+    nil
+  end
+
+  def akismet_is_spam?(_options = {})
+    return false if akismet.nil?
+
+    begin
+      Timeout.timeout(60) do
+        akismet.comment_check(ip, user_agent, akismet_options)
+      end
+    rescue Timeout::Error
+      nil
+    end
+  end
+
+  def change_state!
+    result = ""
+    if spam? || presumed_spam?
+      mark_as_ham!
+      result = "ham"
+    else
+      mark_as_spam!
+      result = "spam"
+    end
+    result
+  end
+
+  def confirm_classification!
+    confirm_classification
+    save!
+  end
+
+  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)
+      end
+    rescue Timeout::Error
+      nil
+    end
+  end
+
+  def report_as_ham
+    return if akismet.nil?
+
+    begin
+      Timeout.timeout(5) do
+        akismet.ham(ip, user_agent, akismet_options)
+      end
+    rescue Timeout::Error
+      nil
+    end
+  end
+
+  def feedback_not_closed
+    errors.add(:article_id, "Comment are closed") if article.comments_closed?
+  end
+
+  def send_notifications
+    nil
+  end
+
+  def published?
+    ham? || presumed_ham?
+  end
+
+  def status_confirmed?
+    ham? || spam?
+  end
+
+  def spammy?
+    spam? || presumed_spam?
+  end
+
+  delegate :blog, to: :article
+
+  private
+
+  def akismet
+    @akismet ||= akismet_client
+  end
+
+  def akismet_client
+    return nil if blog.sp_akismet_key.blank?
+
+    client = Akismet::Client.new(blog.sp_akismet_key, blog.base_url)
+    begin
+      client.verify_key ? client : nil
+    rescue SocketError
+      nil
+    end
+  end
+
+  def blog_id
+    article.blog_id if article.present?
+  end
+end

data/app/models/meta_sidebar.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class MetaSidebar < Sidebar
+  description "This widget just displays links to Publify main site," \
+    " this blog's admin and RSS."
+
+  setting :title, "Meta"
+end
+
+SidebarRegistry.register_sidebar MetaSidebar

data/app/models/note.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+class Note < Content
+  require "twitter"
+  require "json"
+  require "uri"
+  include PublifyGuid
+  include ConfigManager
+
+  serialize :settings, Hash
+
+  setting :twitter_id, :string, ""
+  setting :in_reply_to_status_id, :string, ""
+  setting :in_reply_to_protected, :boolean, false
+  setting :in_reply_to_message, :string, ""
+
+  validates :body, presence: true
+  validates :permalink, :guid, uniqueness: true
+
+  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
+  TWITTER_HTTP_URL_LENGTH = 20
+  TWITTER_HTTPS_URL_LENGTH = 21
+  TWITTER_LINK_LENGTH = 22
+
+  def set_permalink
+    self.permalink = "#{id}-#{body.to_permalink[0..79]}" if permalink.blank?
+    save
+  end
+
+  def categories
+    []
+  end
+
+  def tags
+    []
+  end
+
+  def html_preprocess(_field, html)
+    PublifyApp::Textfilter::Twitterfilter.filtertext(html)
+  end
+
+  def truncate(message, length)
+    if message[length + 1] == " "
+      message[0..length]
+    else
+      message[0..(message[0..length].rindex(" ") - 1)]
+    end
+  end
+
+  def twitter_message
+    base_message = body.strip_html
+    if too_long?("#{base_message} (#{short_link})")
+      max_length = 140 - "... (#{redirect.from_url})".length - 1
+      "#{truncate(base_message, max_length)}... (#{redirect.from_url})"
+    else
+      "#{base_message} (#{short_link})"
+    end
+  end
+
+  # FIXME: This breaks if the user changes or deletes their handle.
+  def twitter_url
+    File.join("https://twitter.com", user.twitter, "status", twitter_id)
+  end
+
+  def send_to_twitter
+    return false unless blog.has_twitter_configured?
+    return false unless user.has_twitter_configured?
+
+    twitter = Twitter::REST::Client.new do |config|
+      config.consumer_key = blog.twitter_consumer_key
+      config.consumer_secret = blog.twitter_consumer_secret
+      config.access_token = user.twitter_oauth_token
+      config.access_token_secret = user.twitter_oauth_token_secret
+    end
+
+    begin
+      options = {}
+      if in_reply_to_status_id && in_reply_to_status_id != ""
+        options = { in_reply_to_status_id: in_reply_to_status_id }
+        self.in_reply_to_message = twitter.status(in_reply_to_status_id).to_json
+      end
+      tweet = twitter.update(twitter_message, options)
+      self.twitter_id = tweet.attrs[:id_str]
+      save
+      user.update_twitter_profile_image(tweet.attrs[:user][:profile_image_url])
+      true
+    rescue StandardError => e
+      Rails.logger.error("Error while sending to twitter: #{e}")
+      errors.add(:message, e)
+      false
+    end
+  end
+
+  content_fields :body
+
+  def password_protected?
+    false
+  end
+
+  def access_by?(user)
+    user.admin? || user_id == user.id
+  end
+
+  def permalink_url(anchor = nil, only_path = false)
+    blog.url_for(
+      controller: "/notes",
+      action: "show",
+      permalink: permalink,
+      anchor: anchor,
+      only_path: only_path)
+  end
+
+  def short_link
+    path = redirect.from_path
+    "#{prefix} #{path}"
+  end
+
+  def prefix
+    blog.shortener_url.sub(%r{^https?://}, "")
+  end
+
+  def published?
+    state == "published"
+  end
+
+  private
+
+  def too_long?(message)
+    uris = URI.extract(message, %w(http https ftp))
+    uris << prefix
+    uris.each do |uri|
+      payload = case uri.split(":")[0]
+                when "https"
+                  "-" * TWITTER_HTTPS_URL_LENGTH
+                when "ftp"
+                  "-" * TWITTER_FTP_URL_LENGTH
+                else
+                  "-" * TWITTER_HTTP_URL_LENGTH
+                end
+      message = message.gsub(uri, payload)
+    end
+    message.length > 140
+  end
+end