publify_core 9.0.0.pre5 → 9.2.0

data/app/models/static_sidebar.rb

@@ -1,19 +1,21 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 class StaticSidebar < Sidebar
-  DEFAULT_TEXT = '
-<ul>
-  <li><a href="http://www.publify.co/" 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>
+  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
 
-'.freeze
-  description 'Static content, like links to other sites, advertisements, or blog meta-information'
+  description "Static content, like links to other sites, advertisements," \
+    " or blog meta-information"
 
-  setting :title, 'Links'
+  setting :title, "Links"
   setting :body, DEFAULT_TEXT, input_type: :text_area
 end
 

data/app/models/tag.rb

@@ -1,6 +1,8 @@
-class Tag < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Tag < ApplicationRecord
   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
@@ -12,10 +14,11 @@ class Tag < ActiveRecord::Base
 
   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("\"'", '')
+      tagwords = article.keywords.to_s.scan(/((['"]).*?\2|[.:[[:alnum:]]]+)/).map do |x|
+        x.first.tr("\"'", "")
       end
       tagwords.uniq.each do |tagword|
         tagname = tagword.to_url
@@ -30,34 +33,39 @@ 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)
-    where('name LIKE ? ', "%#{char}%").order('name ASC')
+    where("name LIKE ? ", "%#{char}%").order("name ASC")
   end
 
   def self.collection_to_string(tags)
-    tags.map(&:display_name).sort.map { |name| name =~ / / ? "\"#{name}\"" : name }.join ', '
+    tags.map(&:display_name).sort.
+      map { |name| / /.match?(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)
+    blog.url_for(controller: "tags", action: "show", id: permalink, only_path: only_path)
   end
 end

data/app/models/tag_sidebar.rb

@@ -1,20 +1,23 @@
+# frozen_string_literal: true
+
 class TagSidebar < Sidebar
-  display_name 'Tags'
-  description 'Show most popular tags for this blog'
+  display_name "Tags"
+  description "Show most popular tags for this blog"
 
   setting :maximum_tags, 20
 
   def tags
-    @tags ||= Tag.find_all_with_article_counters.
+    @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.article_counter }
-    average = total.to_f / @tags.size.to_f
-    @sizes = @tags.reduce({}) do |h, tag|
-      size = tag.article_counter.to_f / average
+
+    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

data/app/models/text_filter.rb

@@ -1,15 +1,28 @@
-require 'net/http'
+# frozen_string_literal: true
 
-class TextFilter < ActiveRecord::Base
-  serialize :filters, Array
-  serialize :params, Hash
+require "net/http"
+
+class TextFilter
+  attr_accessor :description, :filters, :markup, :name, :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)
-    find_by(name: name) || find_by(name: 'none')
+    make_filter(name) || none
   end
 
   def self.filter_text(text, filters)
@@ -17,8 +30,10 @@ class TextFilter < ActiveRecord::Base
 
     filters.each do |filter|
       next if filter.nil?
+
       filter_class = map[filter.to_s]
       next unless filter_class
+
       text = filter_class.filtertext(text)
     end
 
@@ -35,12 +50,16 @@ class TextFilter < ActiveRecord::Base
 
     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 }
+    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|
-      f.help_text.blank? ? '' : "<h3>#{f.display_name}</h3>\n#{BlueCloth.new(f.help_text).to_html}\n"
+      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")
@@ -52,10 +71,65 @@ class TextFilter < ActiveRecord::Base
     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"
+    help.map do |f|
+      f.help_text.blank? ? "" : "#{BlueCloth.new(f.help_text).to_html}\n"
     end.join("\n")
+  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
 
-    help_text
+  def self.none
+    new(name: "none",
+        description: "None",
+        markup: "none")
   end
 end

data/app/models/trackback.rb

@@ -1,35 +1,30 @@
-require_dependency 'spam_protection'
+# 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
 
-  # attr_accessible :url, :blog_name, :title, :excerpt, :ip, :published, :article_id
-
-  def initialize(*args, &block)
-    super(*args, &block)
-    self.title ||= url
-    self.blog_name ||= ''
-  end
-
   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] << '...'
+      self.excerpt = excerpt[0..246] << "..."
     end
   end
 
   def article_allows_feedback?
     return true if article.allow_pings?
-    errors.add(:article, 'Article is not pingable')
+
+    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')
+
+    errors.add(:article, "Pings are disabled")
     false
   end
 
@@ -45,12 +40,6 @@ class Trackback < Feedback
     self.excerpt = newval
   end
 
-  def rss_author(_xml); end
-
-  def rss_title(xml)
-    xml.title feed_title
-  end
-
   def feed_title
     "Trackback from #{blog_name}: #{title} on #{article.title}"
   end

data/app/models/trigger.rb

@@ -1,45 +1,34 @@
-class Trigger < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Trigger < ApplicationRecord
   belongs_to :pending_item, polymorphic: true
 
   class << self
-    def post_action(due_at, item, method = 'came_due')
+    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.now).destroy_all
+      where("due_at <= ?", Time.zone.now).destroy_all
       true
-    rescue
-      migrator = Migrator.new
-
-      unless migrator.pending_migrations.empty?
-        starting_version = migrator.current_schema_version
-        migrator.migrate
-
-        if starting_version == 0
-          load "#{Rails.root}/Rakefile"
-          Rake::Task['db:seed'].invoke
-          User.reset_column_information
-          Article.reset_column_information
-          Page.reset_column_information
-        end
-      end
     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) if pending_item
+    pending_item&.send(trigger_method)
     true
   end
 end

data/app/models/user.rb

@@ -1,11 +1,13 @@
-require 'digest/sha1'
+# frozen_string_literal: true
+
+require "digest/sha1"
 
 # Publify user.
 # TODO: Should belong to a blog
-class User < ActiveRecord::Base
-  ADMIN = 'admin'.freeze
-  PUBLISHER = 'publisher'.freeze
-  CONTRIBUTOR = 'contributor'.freeze
+class User < ApplicationRecord
+  ADMIN = "admin"
+  PUBLISHER = "publisher"
+  CONTRIBUTOR = "contributor"
 
   # Include default devise modules. Others available are:
   # :confirmable, :lockable, :timeoutable and :omniauthable
@@ -13,14 +15,17 @@ class User < ActiveRecord::Base
          :recoverable, :rememberable, :trackable, :validatable
   include ConfigManager
 
-  belongs_to :text_filter
-  belongs_to :resource, optional: true
+  before_validation :set_default_profile
 
-  delegate :name, to: :text_filter, prefix: true
+  validates :login, uniqueness: true, on: :create
+  validates :email, uniqueness: true, on: :create
+  validates :email, :login, presence: true
+  validates :login, length: { in: 3..40 }
 
-  has_many :notifications, foreign_key: 'notify_user_id'
+  belongs_to :resource, optional: true
+  has_many :notifications, foreign_key: "notify_user_id"
   has_many :notify_contents, -> { uniq }, through: :notifications,
-                                          source: 'notify_content'
+                                          source: "notify_content"
 
   has_many :articles
 
@@ -32,36 +37,38 @@ class User < ActiveRecord::Base
 
   # Settings
   setting :notify_watch_my_articles, :boolean, true
-  setting :firstname, :string, ''
-  setting :lastname, :string, ''
-  setting :nickname, :string, ''
-  setting :description, :string, ''
-  setting :url, :string, ''
-  setting :msn, :string, ''
-  setting :aim, :string, ''
-  setting :yahoo, :string, ''
-  setting :twitter, :string, ''
-  setting :jabber, :string, ''
-  setting :admin_theme, :string, 'blue'
-  setting :twitter_account, :string, ''
-  setting :twitter_oauth_token, :string, ''
-  setting :twitter_oauth_token_secret, :string, ''
-  setting :twitter_profile_image, :string, ''
+  setting :firstname, :string, ""
+  setting :lastname, :string, ""
+  setting :nickname, :string, ""
+  setting :description, :string, ""
+  setting :url, :string, ""
+  setting :msn, :string, ""
+  setting :aim, :string, ""
+  setting :yahoo, :string, ""
+  setting :twitter, :string, ""
+  setting :jabber, :string, ""
+  setting :admin_theme, :string, "blue"
+  setting :twitter_account, :string, ""
+  setting :twitter_oauth_token, :string, ""
+  setting :twitter_oauth_token_secret, :string, ""
+  setting :twitter_profile_image, :string, ""
 
   # echo "publify" | sha1sum -
   class_attribute :salt
 
   def self.salt
-    '20ac4d290c2293702c64b3b287ae5ea79b26a5c1'
+    "20ac4d290c2293702c64b3b287ae5ea79b26a5c1"
   end
 
   def first_and_last_name
-    return '' unless firstname.present? && lastname.present?
+    return "" unless firstname.present? && lastname.present?
+
     "#{firstname} #{lastname}"
   end
 
   def display_names
-    [:login, :nickname, :firstname, :lastname, :first_and_last_name].map { |f| send(f) }.delete_if(&:empty?)
+    [:login, :nickname, :firstname, :lastname, :first_and_last_name].
+      map { |f| send(f) }.delete_if(&:empty?)
   end
 
   # Authenticate users with old password hashes
@@ -75,23 +82,23 @@ class User < ActiveRecord::Base
       # Update old SHA1 password with new Devise ByCrypt password
       self.encrypted_password = password_digest(password)
       save
-      return true
+      true
     else
       # If not BCrypt password and not old SHA1 password deny access
-      return false
+      false
     end
   end
 
   def active_for_authentication?
-    super && state == 'active'
+    super && state == "active"
   end
 
-  def default_text_filter
-    text_filter
+  def text_filter
+    TextFilter.make_filter(text_filter_name)
   end
 
   def self.to_prefix
-    'author'
+    "author"
   end
 
   def article_counter
@@ -99,9 +106,9 @@ class User < ActiveRecord::Base
   end
 
   def display_name
-    if !nickname.blank?
+    if nickname.present?
       nickname
-    elsif !name.blank?
+    elsif name.present?
       name
     else
       login
@@ -118,31 +125,18 @@ class User < ActiveRecord::Base
 
   def update_twitter_profile_image(img)
     return if twitter_profile_image == img
+
     self.twitter_profile_image = img
     save
   end
 
-  def generate_password!
-    chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
-    newpass = ''
-    8.times { newpass << chars[rand(chars.size - 1)] }
-    self.password = newpass
-  end
-
   def has_twitter_configured?
     twitter_oauth_token.present? && twitter_oauth_token_secret.present?
   end
 
-  protected
-
-  before_validation :set_default_profile
+  private
 
   def set_default_profile
-    self.profile ||= User.count.zero? ? 'admin' : 'contributor'
+    self.profile ||= User.count.zero? ? "admin" : "contributor"
   end
-
-  validates :login, uniqueness: true, on: :create
-  validates :email, uniqueness: true, on: :create
-  validates :email, :login, presence: true
-  validates :login, length: { in: 3..40 }
 end