publify_core 9.0.0.pre1

data/app/models/sidebar.rb

@@ -0,0 +1,138 @@
+require 'sidebar_field'
+
+# This class cannot be autoloaded since other sidebar classes depend on it.
+class Sidebar < ActiveRecord::Base
+  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 => config[field.key])
+    end
+  end
+
+  def admin_state
+    return :active if active_position && (staged_position == active_position || staged_position.nil?)
+    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,20 @@
+# coding: utf-8
+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>
+
+'.freeze
+  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,63 @@
+class Tag < ActiveRecord::Base
+  belongs_to :blog
+  has_and_belongs_to_many :articles, order: 'created_at DESC', join_table: 'articles_tags'
+
+  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 unless display_name.blank?
+  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').
+      group(*Tag.column_names).
+      order('article_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| name =~ / / ? "\"#{name}\"" : name }.join ', '
+  end
+
+  def published_articles
+    articles.already_published
+  end
+
+  def permalink
+    name
+  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,27 @@
+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_article_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
+      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,61 @@
+require 'net/http'
+
+class TextFilter < ActiveRecord::Base
+  serialize :filters, Array
+  serialize :params, Hash
+
+  def sanitize(*args, &blk)
+    self.class.sanitize(*args, &blk)
+  end
+
+  def self.find_or_default(name)
+    find_by(name: name) || find_by(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|
+      f.help_text.blank? ? '' : "<h3>#{f.display_name}</h3>\n#{BlueCloth.new(f.help_text).to_html}\n"
+    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
+end

data/app/models/trackback.rb

@@ -0,0 +1,58 @@
+require_dependency 'spam_protection'
+
+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] << '...'
+    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 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
+end

data/app/models/trigger.rb

@@ -0,0 +1,45 @@
+class Trigger < ActiveRecord::Base
+  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
+      destroy_all ['due_at <= ?', Time.now]
+      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
+
+  before_destroy :trigger_pending_item
+
+  def trigger_pending_item
+    pending_item.send(trigger_method) if pending_item
+    true
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,148 @@
+require 'digest/sha1'
+
+# Publify user.
+# TODO: Should belong to a blog
+class User < ActiveRecord::Base
+  ADMIN = 'admin'.freeze
+  PUBLISHER = 'publisher'.freeze
+  CONTRIBUTOR = 'contributor'.freeze
+
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :trackable, :validatable
+  include ConfigManager
+
+  belongs_to :text_filter
+  belongs_to :resource
+
+  delegate :name, to: :text_filter, prefix: true
+
+  has_many :notifications, foreign_key: 'notify_user_id'
+  has_many :notify_contents, -> { uniq }, through: :notifications,
+                                          source: 'notify_content'
+
+  has_many :articles
+
+  serialize :settings, Hash
+
+  STATUS = %w(active inactive).freeze
+
+  attr_accessor :filename
+
+  # 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, ''
+
+  # echo "publify" | sha1sum -
+  class_attribute :salt
+
+  def self.salt
+    '20ac4d290c2293702c64b3b287ae5ea79b26a5c1'
+  end
+
+  def first_and_last_name
+    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?)
+  end
+
+  # Authenticate users with old password hashes
+  alias devise_valid_password? valid_password?
+
+  def valid_password?(password)
+    devise_valid_password?(password)
+  rescue BCrypt::Errors::InvalidHash
+    digest = Digest::SHA1.hexdigest("#{self.class.salt}--#{password}--")
+    if digest == encrypted_password
+      # Update old SHA1 password with new Devise ByCrypt password
+      self.encrypted_password = password_digest(password)
+      save
+      return true
+    else
+      # If not BCrypt password and not old SHA1 password deny access
+      return false
+    end
+  end
+
+  def active_for_authentication?
+    super && state == 'active'
+  end
+
+  def default_text_filter
+    text_filter
+  end
+
+  def self.to_prefix
+    'author'
+  end
+
+  def article_counter
+    articles.size
+  end
+
+  def display_name
+    if !nickname.blank?
+      nickname
+    elsif !name.blank?
+      name
+    else
+      login
+    end
+  end
+
+  def permalink
+    login
+  end
+
+  def admin?
+    profile == User::ADMIN
+  end
+
+  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
+
+  def set_default_profile
+    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

data/app/services/migrator.rb

@@ -0,0 +1,25 @@
+class Migrator
+  def current_schema_version
+    ActiveRecord::Migrator.current_version
+  end
+
+  def migrations_pending?
+    pending_migrations.any?
+  end
+
+  def pending_migrations
+    all_migrations = ActiveRecord::Migrator.migrations(migrations_paths)
+    migrator = ActiveRecord::Migrator.new(:up, all_migrations)
+    migrator.pending_migrations
+  end
+
+  def migrate
+    ActiveRecord::Migrator.migrate(migrations_paths)
+  end
+
+  private
+
+  def migrations_paths
+    ActiveRecord::Migrator.migrations_paths
+  end
+end

data/app/services/title_builder.rb

@@ -0,0 +1,80 @@
+class TitleBuilder
+  def initialize(template)
+    @template = template
+  end
+
+  def build(item, settings, parameters)
+    s = @template
+
+    s = substitute_parameters(s, parameters)
+    s = substitute_settings(s, settings)
+    s = substitute_item(s, item)
+    s = substitute_time(s, settings)
+
+    s
+  end
+
+  private
+
+  def substitute_time(s, settings)
+    # Other
+    s = s.gsub('%currentdate%', Time.now.strftime(settings.date_format))
+    s = s.gsub('%currenttime%', Time.now.strftime(settings.time_format))
+    s = s.gsub('%currentmonth%', Time.now.strftime('%B'))
+    s = s.gsub('%currentyear%', Time.now.year.to_s)
+    s
+  end
+
+  def substitute_item(s, item)
+    # Tags for item
+    s = s.gsub('%title%', item.title) if s =~ /%title/ && item.respond_to?(:title)
+    s = s.gsub('%excerpt%', item.excerpt_text) if s =~ /%excerpt%/ && item.respond_to?(:excerpt_text)
+    s = s.gsub('%description%', item.description) if s =~ /%description%/ && item.respond_to?(:description)
+    s = s.gsub('%name%', item.name) if s =~ /%name%/ && item.respond_to?(:name)
+    s = s.gsub('%author%', item.name) if s =~ /%author%/ && item.respond_to?(:name)
+    s = s.gsub('%body%', item.body) if s =~ /%body%/ && item.respond_to?(:body)
+
+    if s =~ /%categories%/ && item.respond_to?(:categories)
+      s = s.gsub('%categories%', item.categories.map(&:name).join(', '))
+    end
+
+    if s =~ /%tags%/ && item.respond_to?(:tags)
+      s = s.gsub('%tags%', item.tags.map(&:display_name).join(', '))
+    end
+
+    s
+  end
+
+  def substitute_settings(s, settings)
+    # Tags for settings
+    s = s.gsub('%blog_name%', settings.blog_name)
+    s = s.gsub('%blog_subtitle%', settings.blog_subtitle)
+    s = s.gsub('%meta_keywords%', settings.meta_keywords)
+
+    s
+  end
+
+  def substitute_parameters(s, parameters)
+    s = s.gsub('%date%', parse_date(s, parameters)) if s =~ /%date%/
+    s = s.gsub('%search%', parameters[:q]) if parameters[:q]
+    s = s.gsub('%page%', parse_page(s, parameters)) if s =~ /%page%/
+
+    s
+  end
+
+  def parse_date(string, params)
+    return '' unless params[:year]
+
+    format = ''
+    format << '%A %d ' if params[:day]
+    format << '%B ' if params[:month]
+    format << '%Y' if params[:year]
+
+    string.gsub('%date%', Time.mktime(*params.values_at(:year, :month, :day)).strftime(format))
+  end
+
+  def parse_page(_string, params)
+    return '' unless params[:page]
+    "#{I18n.t('articles.index.page')} #{params[:page]}"
+  end
+end

data/app/uploaders/resource_uploader.rb

@@ -0,0 +1,30 @@
+class ResourceUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+
+  def store_dir
+    "files/#{model.class.to_s.underscore}/#{model.id}"
+  end
+
+  version :thumb, if: :image? do
+    process dynamic_resize_to_fit: :thumb
+  end
+
+  version :medium, if: :image? do
+    process dynamic_resize_to_fit: :medium
+  end
+
+  version :avatar, if: :image? do
+    process dynamic_resize_to_fit: :avatar
+  end
+
+  def dynamic_resize_to_fit(size)
+    resize_setting = model.blog.send("image_#{size}_size").to_i
+
+    resize_to_fit(resize_setting, resize_setting)
+  end
+
+  def image?(new_file)
+    mime_magic_content_type = new_file.send :mime_magic_content_type
+    mime_magic_content_type && mime_magic_content_type.include?('image')
+  end
+end