HornsAndHooves-publify_core 10.0.0

data/app/models/page.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Page < Content
+  validates :title, :body, presence: true
+  validates :name, uniqueness: true
+
+  include ConfigManager
+
+  serialize :settings, Hash
+  setting :password, :string, ""
+
+  before_save :set_permalink
+  after_save :shorten_url
+
+  def set_permalink
+    self.name = title.to_permalink if name.blank?
+  end
+
+  content_fields :body
+
+  def self.default_order
+    "title ASC"
+  end
+
+  def permalink_url(anchor = nil, only_path = false)
+    blog.url_for(
+      controller: "/articles",
+      action: "view_page",
+      name: name,
+      anchor: anchor,
+      only_path: only_path)
+  end
+
+  def publish!
+    self.state = "published"
+    save!
+  end
+
+  def published?
+    state == "published"
+  end
+end

data/app/models/page_sidebar.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class PageSidebar < Sidebar
+  display_name "Page"
+  description "Show pages for this blog"
+
+  setting :maximum_pages, 10
+
+  def pages
+    @pages ||= Page.published.order(:title)
+  end
+end
+
+SidebarRegistry.register_sidebar PageSidebar

data/app/models/ping.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Ping < ApplicationRecord
+  belongs_to :article
+end

data/app/models/post_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class PostType < ApplicationRecord
+  validates :name, uniqueness: true
+  validates :name, presence: true
+  validate :name_is_not_read
+  before_save :sanitize_title
+
+  def name_is_not_read
+    errors.add(:name, I18n.t("errors.article_type_already_exist")) if name == "read"
+  end
+
+  def sanitize_title
+    self.permalink = name.to_permalink
+  end
+end

data/app/models/redirect.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Redirect < ApplicationRecord
+  belongs_to :content, optional: true, touch: true
+  belongs_to :blog
+
+  validates :from_path, uniqueness: true
+  validates :to_path, presence: true
+  validates :blog, presence: true
+
+  def full_to_path
+    path = to_path
+    # FIXME: Unify HTTP URI matchers
+    return path if %r{^(https?)://([^/]*)(.*)}.match?(path)
+
+    url_root = blog.root_path
+    unless url_root.nil? || path[0, url_root.length] == url_root
+      path = File.join(url_root, path)
+    end
+    path
+  end
+
+  def shorten
+    if (temp_token = random_token) && self.class.find_by(from_path: temp_token).nil?
+      temp_token
+    else
+      shorten
+    end
+  end
+
+  def to_url
+    raise "Use #from_url"
+  end
+
+  def from_url
+    File.join(blog.shortener_url, from_path)
+  end
+
+  private
+
+  def random_token
+    characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"
+    temp_token = ""
+    srand
+    6.times do
+      pos = rand(characters.length)
+      temp_token += characters[pos..pos]
+    end
+    temp_token
+  end
+end

data/app/models/redirection.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Redirection < ApplicationRecord
+  belongs_to :content
+  belongs_to :redirect
+end

data/app/models/resource.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "carrierwave"
+require "carrierwave/orm/activerecord"
+
+class Resource < ApplicationRecord
+  belongs_to :blog
+  belongs_to :content, optional: true
+
+  mount_uploader :upload, ResourceUploader
+  validates :upload, presence: true
+end

data/app/models/search_sidebar.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class SearchSidebar < Sidebar
+  description "Adds basic search sidebar in your Publify blog"
+
+  setting :title, "Search"
+end
+
+SidebarRegistry.register_sidebar SearchSidebar

data/app/models/sidebar.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "sidebar_field"
+
+# This class cannot be autoloaded since other sidebar classes depend on it.
+class Sidebar < ApplicationRecord
+  serialize :config, Hash
+
+  belongs_to :blog
+
+  scope :valid, ->() { where(type: SidebarRegistry.available_sidebar_types) }
+
+  def self.ordered_sidebars
+    os = []
+    Sidebar.valid.each do |s|
+      if s.staged_position
+        os[s.staged_position] = ((os[s.staged_position] || []) << s).uniq
+      elsif s.active_position
+        os[s.active_position] = ((os[s.active_position] || []) << s).uniq
+      end
+      if s.active_position.nil? && s.staged_position.nil?
+        s.destroy # neither staged nor active: destroy. Full stop.
+      end
+    end
+    os.flatten.compact
+  end
+
+  def self.purge
+    delete_all("active_position is null and staged_position is null")
+  end
+
+  def self.setting(key, default = nil, options = {})
+    key = key.to_s
+
+    return if instance_methods.include?(key)
+
+    fields << SidebarField.build(key, default, options)
+
+    send(:define_method, key) do
+      if config.key? key
+        config[key]
+      else
+        default
+      end
+    end
+
+    send(:define_method, "#{key}=") do |newval|
+      config[key] = newval
+    end
+  end
+
+  def self.fields
+    @fields ||= []
+  end
+
+  def self.description(desc = nil)
+    if desc
+      @description = desc
+    else
+      @description || ""
+    end
+  end
+
+  def self.short_name
+    to_s.underscore.split(/_/).first
+  end
+
+  def self.path_name
+    to_s.underscore
+  end
+
+  def self.display_name(new_dn = nil)
+    @display_name = new_dn if new_dn
+    @display_name || short_name.humanize
+  end
+
+  class << self
+    attr_writer :fields
+  end
+
+  def self.apply_staging_on_active!
+    Sidebar.transaction do
+      Sidebar.find_each do |s|
+        s.active_position = s.staged_position
+        s.save!
+      end
+    end
+  end
+
+  def publish
+    self.active_position = staged_position
+  end
+
+  def html_id
+    short_name + "-" + id.to_s
+  end
+
+  def parse_request(_contents, _params); end
+
+  def fields
+    self.class.fields
+  end
+
+  def fieldmap(field = nil)
+    if field
+      self.class.fieldmap[field.to_s]
+    else
+      self.class.fieldmap
+    end
+  end
+
+  def description
+    self.class.description
+  end
+
+  def short_name
+    self.class.short_name
+  end
+
+  def display_name
+    self.class.display_name
+  end
+
+  def content_partial
+    "/#{self.class.path_name}/content"
+  end
+
+  def to_locals_hash
+    fields.reduce(sidebar: self) do |hash, field|
+      hash.merge(field.key => field.current_value(self))
+    end
+  end
+
+  def admin_state
+    if active_position && (staged_position == active_position || staged_position.nil?)
+      return :active
+    end
+    return :will_change_position if active_position != staged_position
+
+    raise "Unknown admin_state: active: #{active_position}, staged: #{staged_position}"
+  end
+end

data/app/models/static_sidebar.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class StaticSidebar < Sidebar
+  DEFAULT_TEXT = <<~TEXT
+    <ul>
+      <li><a href="https://publify.github.io/" title="Publify">Publify</a></li>
+      <li><a href="http://t37.net/" title="Le Rayon UX">Frédéric</a></li>
+      <li><a href="http://www.matijs.net/" title="Matijs">Matijs</a></li>
+      <li><a href="http://elsif.fr/" title="Yannick">Yannick</a></li>
+      <li><a href="http://blog.ookook.fr/" title="Thomas">Thomas</a></li>
+      <li><a href="/admin">Admin</a></li>
+    </ul>
+  TEXT
+
+  description "Static content, like links to other sites, advertisements," \
+    " or blog meta-information"
+
+  setting :title, "Links"
+  setting :body, DEFAULT_TEXT, input_type: :text_area
+end
+
+SidebarRegistry.register_sidebar StaticSidebar

data/app/models/tag.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class Tag < ApplicationRecord
+  belongs_to :blog
+  has_and_belongs_to_many :contents, order: "created_at DESC"
+
+  validates :name, uniqueness: { scope: :blog_id }
+  validates :blog, presence: true
+  validates :name, presence: true
+
+  before_validation :ensure_naming_conventions
+
+  attr_accessor :description, :keywords
+
+  def self.create_from_article!(article)
+    return if article.keywords.nil?
+
+    tags = []
+    Tag.transaction do
+      tagwords = article.keywords.to_s.scan(/((['"]).*?\2|[\.:[[:alnum:]]]+)/).map do |x|
+        x.first.tr("\"'", "")
+      end
+      tagwords.uniq.each do |tagword|
+        tagname = tagword.to_url
+        tags << article.blog.tags.find_or_create_by(name: tagname) do |tag|
+          tag.display_name = tagword
+        end
+      end
+    end
+    article.tags = tags
+    tags
+  end
+
+  def ensure_naming_conventions
+    self.display_name = name if display_name.blank?
+    self.name = display_name.to_url if display_name.present?
+  end
+
+  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("content_counter DESC").limit(1000)
+  end
+
+  def self.find_with_char(char)
+    where("name LIKE ? ", "%#{char}%").order("name ASC")
+  end
+
+  def self.collection_to_string(tags)
+    tags.map(&:display_name).sort.
+      map { |name| / /.match?(name) ? "\"#{name}\"" : name }.join ", "
+  end
+
+  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
+end

data/app/models/tag_sidebar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class TagSidebar < Sidebar
+  display_name "Tags"
+  description "Show most popular tags for this blog"
+
+  setting :maximum_tags, 20
+
+  def tags
+    @tags ||= Tag.find_all_with_content_counters.
+      take(maximum_tags.to_i).sort_by(&:name)
+  end
+
+  def sizes
+    return @sizes if @sizes
+
+    total = tags.reduce(0) { |sum, tag| sum + tag.content_counter }
+    average = total.to_f / @tags.size
+    @sizes = tags.reduce({}) do |h, tag|
+      size = tag.content_counter.to_f / average
+      h.merge tag => [[2.0 / 3.0, size].max, 2].min * 100
+    end
+  end
+
+  def font_multiplier
+    80
+  end
+end
+
+SidebarRegistry.register_sidebar TagSidebar

data/app/models/text_filter.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+class TextFilter
+  attr_accessor :description
+  attr_accessor :filters
+  attr_accessor :markup
+  attr_accessor :name
+  attr_accessor :params
+
+  def initialize(name: nil,
+                 description: nil,
+                 markup: nil,
+                 filters: [],
+                 params: nil)
+    @name = name
+    @description = description
+    @markup = markup
+    @filters = filters
+    @params = params
+  end
+
+  def sanitize(*args, &blk)
+    self.class.sanitize(*args, &blk)
+  end
+
+  def self.find_or_default(name)
+    make_filter(name) || none
+  end
+
+  def self.filter_text(text, filters)
+    map = TextFilterPlugin.filter_map
+
+    filters.each do |filter|
+      next if filter.nil?
+
+      filter_class = map[filter.to_s]
+      next unless filter_class
+
+      text = filter_class.filtertext(text)
+    end
+
+    text
+  end
+
+  def filter_text(text)
+    self.class.filter_text(text, [:macropre, markup, :macropost, filters].flatten)
+  end
+
+  def help
+    filter_map = TextFilterPlugin.filter_map
+    filter_types = TextFilterPlugin.available_filter_types
+
+    help = []
+    help.push(filter_map[markup])
+    filter_types["macropre"].sort_by(&:short_name).each { |f| help.push f }
+    filter_types["macropost"].sort_by(&:short_name).each { |f| help.push f }
+    filters.each { |f| help.push(filter_map[f.to_s]) }
+
+    help_text = help.map do |f|
+      if f.help_text.blank?
+        ""
+      else
+        "<h3>#{f.display_name}</h3>\n#{BlueCloth.new(f.help_text).to_html}\n"
+      end
+    end
+
+    help_text.join("\n")
+  end
+
+  def commenthelp
+    filter_map = TextFilterPlugin.filter_map
+
+    help = [filter_map[markup]]
+    filters.each { |f| help.push(filter_map[f.to_s]) }
+
+    help_text = help.map do |f|
+      f.help_text.blank? ? "" : "#{BlueCloth.new(f.help_text).to_html}\n"
+    end.join("\n")
+
+    help_text
+  end
+
+  def self.all
+    [
+      markdown,
+      smartypants,
+      markdown_smartypants,
+      textile,
+      none,
+    ]
+  end
+
+  def self.make_filter(name)
+    case name
+    when "markdown"
+      markdown
+    when "smartypants"
+      smartypants
+    when "markdown smartypants"
+      markdown_smartypants
+    when "textile"
+      textile
+    when "none"
+      none
+    end
+  end
+
+  def self.markdown
+    new(name: "markdown",
+        description: "Markdown",
+        markup: "markdown")
+  end
+
+  def self.smartypants
+    new(name: "smartypants",
+        description: "SmartyPants",
+        markup: "none",
+        filters: [:smartypants])
+  end
+
+  def self.markdown_smartypants
+    new(name: "markdown smartypants",
+        description: "Markdown with SmartyPants",
+        markup: "markdown",
+        filters: [:smartypants])
+  end
+
+  def self.textile
+    new(name: "textile",
+        description: "Textile",
+        markup: "textile")
+  end
+
+  def self.none
+    new(name: "none",
+        description: "None",
+        markup: "none")
+  end
+end

data/app/models/trackback.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Legacy class to support old feedback sent as trackbacks.
+class Trackback < Feedback
+  content_fields :excerpt
+  validates :title, :excerpt, :url, presence: true
+
+  before_create :process_trackback
+
+  def process_trackback
+    if excerpt.length >= 251
+      # this limits excerpt to 250 chars, including the trailing "..."
+      self.excerpt = excerpt[0..246] << "..."
+    end
+  end
+
+  def article_allows_feedback?
+    return true if article.allow_pings?
+
+    errors.add(:article, "Article is not pingable")
+    false
+  end
+
+  def blog_allows_feedback?
+    return true unless blog.global_pings_disable
+
+    errors.add(:article, "Pings are disabled")
+    false
+  end
+
+  def originator
+    blog_name
+  end
+
+  def body
+    excerpt
+  end
+
+  def body=(newval)
+    self.excerpt = newval
+  end
+
+  def feed_title
+    "Trackback from #{blog_name}: #{title} on #{article.title}"
+  end
+end

data/app/models/trigger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Trigger < ApplicationRecord
+  belongs_to :pending_item, polymorphic: true
+
+  class << self
+    def post_action(due_at, item, method = "came_due")
+      create!(due_at: due_at, pending_item: item,
+              trigger_method: method)
+      fire
+    end
+
+    def fire
+      where("due_at <= ?", Time.zone.now).destroy_all
+      true
+    end
+
+    def remove(pending_item, conditions = {})
+      return if pending_item.new_record?
+
+      conditions = conditions.merge(pending_item_id: pending_item.id,
+                                    pending_item_type: pending_item.class.to_s)
+      where(conditions).delete_all
+    end
+  end
+
+  # TODO: Ensure errors bubble up to where they are visible
+  before_destroy :trigger_pending_item
+
+  def trigger_pending_item
+    pending_item&.send(trigger_method)
+    true
+  end
+end