publify_core 9.0.0.pre1

data/app/models/feedback.rb

@@ -0,0 +1,225 @@
+require_dependency 'spam_protection'
+require 'akismet'
+
+class Feedback < ActiveRecord::Base
+  self.table_name = 'feedback'
+
+  belongs_to :text_filter
+  belongs_to :article
+
+  include PublifyGuid
+  include Stateful
+  include ContentBase
+  include States
+
+  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, :before_save_handler
+  after_save :post_trigger, :report_classification, :invalidates_cache?
+  after_initialize :after_initialize_handler
+  after_destroy ->(c) { c.invalidates_cache?(true) }
+
+  scope :ham, -> { where(state: %w(presumed_ham ham)) }
+  scope :spam, -> { where(state: 'spam') }
+  scope :published_since, ->(time) { ham.where('published_at > ?', time) }
+  scope :presumed_ham, -> { where(state: 'presumed_ham') }
+  scope :presumed_spam, -> { where(state: 'presumed_spam') }
+  scope :unapproved, -> { where(status_confirmed: false) }
+
+  scope :published, -> { where(published: true) }
+  scope :oldest_first, -> { order(:created_at) }
+
+  has_state(:state,
+            valid_states: [:unclassified, :presumed_spam, :just_marked_as_spam, :spam, :just_presumed_ham, :presumed_ham, :just_marked_as_ham, :ham],
+            handles: [:published?, :status_confirmed?, :just_published?,
+                      :mark_as_ham, :mark_as_spam, :confirm_classification,
+                      :withdraw,
+                      :before_save_handler, :after_initialize_handler,
+                      :send_notifications, :post_trigger, :report_classification])
+
+  def self.paginated(page, per_page)
+    page(page).per(per_page)
+  end
+
+  def self.comments
+    Comment.where(published: true).order('created_at DESC')
+  end
+
+  def self.trackbacks
+    Trackback.where(published: true).order('created_at DESC')
+  end
+
+  def self.from(type, article_id = nil)
+    if article_id.present?
+      Article.find(article_id).send("published_#{type}")
+    else
+      send(type)
+    end
+  end
+
+  def parent
+    article
+  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 url =~ %r{^https?://}
+  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 state.spam? || state.presumed_spam?
+      mark_as_ham
+      result = 'ham'
+    else
+      mark_as_spam
+      result = 'spam'
+    end
+    save!
+    result
+  end
+
+  def mark_as_ham!
+    mark_as_ham
+    save!
+  end
+
+  def mark_as_spam!
+    mark_as_spam
+    save!
+  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 withdraw!
+    withdraw
+    save!
+  end
+
+  def confirm_classification!
+    confirm_classification
+    save
+  end
+
+  def feedback_not_closed
+    errors.add(:article_id, 'Comment are closed') if article.comments_closed?
+  end
+
+  delegate :blog, to: :article
+
+  private
+
+  @@akismet = nil
+
+  def akismet
+    @@akismet = akismet_client if @@akismet.nil?
+    @@akismet == false ? nil : @@akismet
+  end
+
+  def akismet_client
+    return false if blog.sp_akismet_key.blank?
+    client = Akismet::Client.new(blog.sp_akismet_key, blog.base_url)
+    begin
+      return client.verify_key ? client : false
+    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,8 @@
+# coding: utf-8
+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,144 @@
+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
+
+  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(/^https?\:\/\//, '')
+  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

data/app/models/page.rb

@@ -0,0 +1,36 @@
+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
+    'name ASC'
+  end
+
+  def self.search_with(search_hash)
+    super(search_hash).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
+end

data/app/models/page_cache.rb

@@ -0,0 +1,33 @@
+# FIXME: This class is not a model anymore. Move elsewhere?
+class PageCache
+  def self.logger
+    ::Rails.logger
+  end
+
+  def logger
+    ::Rails.logger
+  end
+
+  def self.public_path
+    ActionController::Base.page_cache_directory
+  end
+
+  # Delete all file save in path_cache by page_cache system
+  def self.sweep_all
+    zap_pages(%w(*))
+  end
+
+  def self.sweep_theme_cache
+    zap_pages(%w(images/theme/* stylesheets/theme/* javascripts/theme/*))
+  end
+
+  def self.zap_pages(paths)
+    # Ensure no one is going to wipe his own blog public directory
+    # It happened once on a release and was no fun at all
+    return if public_path == "#{::Rails.root}/public"
+    paths.each do |v|
+      FileUtils.rm_rf(Dir.glob(public_path + "/#{v}"))
+    end
+    true
+  end
+end

data/app/models/page_sidebar.rb

@@ -0,0 +1,12 @@
+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,116 @@
+require 'rexml/document'
+require 'xmlrpc/client'
+
+class Ping < ActiveRecord::Base
+  belongs_to :article
+
+  class Pinger
+    attr_accessor :article
+    attr_accessor :blog
+
+    def send_pingback_or_trackback
+      @response = Net::HTTP.get_response(URI.parse(ping.url))
+      send_pingback or send_trackback
+    rescue Timeout::Error
+      Rails.logger.info 'Sending pingback or trackback timed out'
+      return
+    rescue => err
+      Rails.logger.info "Sending pingback or trackback failed with error: #{err}"
+    end
+
+    def pingback_url
+      if response['X-Pingback']
+        response['X-Pingback']
+      elsif response.body =~ /<link rel="pingback" href="([^"]+)" ?\/?>/
+        Regexp.last_match[1]
+      end
+    end
+
+    attr_reader :origin_url
+
+    attr_reader :response
+
+    attr_reader :ping
+
+    def send_xml_rpc(*args)
+      ping.send(:send_xml_rpc, *args)
+    end
+
+    def trackback_url
+      rdfs = response.body.scan(/<rdf:RDF.*?<\/rdf:RDF>/m)
+      rdfs.each do |rdf|
+        xml = REXML::Document.new(rdf)
+        xml.elements.each('//rdf:Description') do |desc|
+          if rdfs.size == 1 || desc.attributes['dc:identifier'] == ping.url
+            return desc.attributes['trackback:ping']
+          end
+        end
+      end
+      # Didn't find a trackback url, so fall back to the url itself.
+      @ping.url
+    end
+
+    def send_pingback
+      if pingback_url
+        send_xml_rpc(pingback_url, 'pingback.ping', origin_url, ping.url)
+        true
+      else
+        false
+      end
+    end
+
+    def send_trackback
+      do_send_trackback(trackback_url, origin_url)
+    end
+
+    def do_send_trackback(trackback_url, origin_url)
+      trackback_uri = URI.parse(trackback_url)
+
+      post = "title=#{CGI.escape(article.title)}"
+      post << "&excerpt=#{CGI.escape(article.html(:body).strip_html[0..254])}"
+      post << "&url=#{origin_url}"
+      post << "&blog_name=#{CGI.escape(blog.blog_name)}"
+
+      path = trackback_uri.path
+      path += "?#{trackback_uri.query}" if trackback_uri.query
+
+      Net::HTTP.start(trackback_uri.host, trackback_uri.port) do |http|
+        http.post(path, post, 'Content-type' => 'application/x-www-form-urlencoded; charset=utf-8')
+      end
+    end
+
+    private
+
+    def initialize(origin_url, ping)
+      @origin_url = origin_url
+      @ping = ping
+      # Add this call to text filter cause of a strange thing around text_filter. Need to clean text_filter usage !
+      ping.article.default_text_filter
+      ping.article.text_filter
+      # Make sure these are fetched now for thread safety purposes.
+      self.article = ping.article
+      self.blog = article.blog
+    end
+  end
+
+  def send_pingback_or_trackback(origin_url)
+    t = Thread.start(Pinger.new(origin_url, self), &:send_pingback_or_trackback)
+    t
+  end
+
+  def send_weblogupdatesping(server_url, origin_url)
+    t = Thread.start(article.blog.blog_name) do |blog_name|
+      send_xml_rpc(url, 'weblogUpdates.ping', blog_name, server_url, origin_url)
+    end
+    t
+  end
+
+  protected
+
+  def send_xml_rpc(xml_rpc_url, name, *args)
+    server = XMLRPC::Client.new2(URI.parse(xml_rpc_url).to_s)
+    server.call(name, *args)
+  rescue => e
+    logger.error(e)
+  end
+end

data/app/models/post_type.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class PostType < ActiveRecord::Base
+  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,45 @@
+class Redirect < ActiveRecord::Base
+  belongs_to :contents
+  belongs_to :blog
+
+  validates :from_path, uniqueness: true
+  validates :to_path, presence: true
+  validates :blog, presence: true
+
+  def full_to_path
+    path = to_path
+    return path if path =~ /^(https?):\/\/([^\/]*)(.*)/
+    url_root = blog.root_path
+    path = File.join(url_root, path) unless url_root.nil? || path[0, url_root.length] == url_root
+    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,4 @@
+class Redirection < ActiveRecord::Base
+  belongs_to :content
+  belongs_to :redirect
+end

data/app/models/resource.rb

@@ -0,0 +1,28 @@
+require 'carrierwave'
+require 'carrierwave/orm/activerecord'
+
+class Resource < ActiveRecord::Base
+  belongs_to :blog
+  belongs_to :article
+
+  mount_uploader :upload, ResourceUploader
+  validate :image_mime_type_consistent
+  validates :upload, presence: true
+
+  scope :without_images, -> { where("mime NOT LIKE '%image%'") }
+  scope :images, -> { where("mime LIKE '%image%'") }
+  scope :by_filename, -> { order('upload') }
+  scope :by_created_at, -> { order('created_at DESC') }
+
+  scope :without_images_by_filename, -> { without_images.by_filename }
+  scope :images_by_created_at, -> { images.by_created_at }
+
+  private
+
+  def image_mime_type_consistent
+    if upload.content_type =~ %r{^image/}
+      expected_type = upload.file.send :mime_magic_content_type
+      errors.add(:upload, 'Has MIME type mismatch') unless upload.content_type == expected_type
+    end
+  end
+end

data/app/models/search_sidebar.rb

@@ -0,0 +1,7 @@
+class SearchSidebar < Sidebar
+  description 'Adds basic search sidebar in your Publify blog'
+
+  setting :title, 'Search'
+end
+
+SidebarRegistry.register_sidebar SearchSidebar