publify_core 9.0.0.pre1

data/app/helpers/base_helper.rb

@@ -0,0 +1,246 @@
+# coding: utf-8
+# Methods added to this helper will be available to all templates in the application.
+require 'digest/sha1'
+
+module BaseHelper
+  include BlogHelper
+
+  # Need to rewrite this one, quick hack to test my changes.
+  attr_reader :page_title
+
+  def render_sidebars(*sidebars)
+    rendered_sidebars = (sidebars.blank? ? Sidebar.order(:active_position) : sidebars).map do |sb|
+      @sidebar = sb
+      sb.parse_request(content_array, params)
+      render_sidebar(sb)
+    end
+    safe_join rendered_sidebars
+  rescue => e
+    logger.error e
+    logger.error e.backtrace.join("\n")
+    I18n.t('errors.render_sidebar')
+  end
+
+  def render_sidebar(sidebar)
+    render_to_string(partial: sidebar.content_partial, locals: sidebar.to_locals_hash, layout: false)
+  end
+
+  def themeable_stylesheet_link_tag(name)
+    src = this_blog.current_theme.path + "/stylesheets/#{name}.css"
+    stylesheet_link_tag "/stylesheets/theme/#{name}.css" if File.exist? src
+  end
+
+  def render_to_string(*args, &block)
+    controller.send(:render_to_string, *args, &block)
+  end
+
+  def link_to_permalink(item, title, anchor = nil, style = nil, nofollow = nil, only_path = false)
+    options = {}
+    options[:class] = style if style
+    options[:rel] = 'nofollow' if nofollow
+    link_to title, item.permalink_url(anchor, only_path), options
+  end
+
+  def avatar_tag(options = {})
+    begin
+      avatar_class = this_blog.plugin_avatar.constantize
+    rescue NameError
+      return ''
+    end
+    return '' unless avatar_class.respond_to?(:get_avatar)
+    avatar_class.get_avatar(options)
+  end
+
+  def meta_tag(name, value)
+    tag :meta, name: name, content: value unless value.blank?
+  end
+
+  def markup_help_popup(markup, text)
+    if markup && markup.commenthelp.size > 1
+      link_to text, url_for(controller: 'articles', action: 'markup_help', id: markup.id), onclick: "return popup(this, 'Publify Markup Help')"
+    else
+      ''
+    end
+  end
+
+  def onhover_show_admin_tools(type, id = nil)
+    admin_id = "#admin_#{[type, id].compact.join('_')}"
+    tag = []
+    tag << %{ onmouseover="if (getCookie('publify_user_profile') == 'admin') { $('#{admin_id}').show(); }" }
+    tag << %{ onmouseout="$('#{admin_id}').hide();" }
+    safe_join(tag, ' ')
+  end
+
+  def feed_title
+    if @feed_title.present?
+      @feed_title
+    elsif @page_title.present?
+      @page_title
+    else
+      this_blog.blog_name
+    end
+  end
+
+  def html(content, what = :all, _deprecated = false)
+    content.html(what)
+  end
+
+  def display_user_avatar(user, size = 'avatar', klass = 'alignleft')
+    if user.resource.present?
+      avatar_path = case size
+                    when 'thumb'
+                      user.resource.upload.thumb.url
+                    when 'medium'
+                      user.resource.upload.medium.url
+                    when 'large'
+                      user.resource.upload.large.url
+                    else
+                      user.resource.upload.avatar.url
+                    end
+      return if avatar_path.nil?
+      avatar_url = File.join(this_blog.base_url, avatar_path)
+    elsif user.twitter_profile_image.present?
+      avatar_url = user.twitter_profile_image
+    end
+    return unless avatar_url
+    image_tag(avatar_url, alt: user.nickname, class: klass)
+  end
+
+  def author_picture(status)
+    return if status.user.twitter_profile_image.blank?
+
+    image_tag(status.user.twitter_profile_image, class: 'alignleft', alt: status.user.nickname)
+  end
+
+  def google_analytics
+    unless this_blog.google_analytics.empty?
+      <<-HTML
+      <script type="text/javascript">
+      var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
+      document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
+      </script>
+      <script type="text/javascript">
+      var pageTracker = _gat._getTracker("#{this_blog.google_analytics}");
+      pageTracker._trackPageview();
+      </script>
+      HTML
+    end
+  end
+
+  def page_header_includes
+    content_array.map(&:whiteboard).map do |w|
+      w.select { |k, _v| k =~ /^page_header_/ }.map do |_, v|
+        v = v.chomp
+        # trim the same number of spaces from the beginning of each line
+        # this way plugins can indent nicely without making ugly source output
+        spaces = /\A[ \t]*/.match(v)[0].gsub(/\t/, '  ')
+        v.gsub!(/^#{spaces}/, '  ') # add 2 spaces to line up with the assumed position of the surrounding tags
+      end
+    end.flatten.uniq.join("\n")
+  end
+
+  def feed_atom
+    feed_for('atom')
+  end
+
+  def feed_rss
+    feed_for('rss')
+  end
+
+  def content_array
+    if @articles
+      @articles
+    elsif @article
+      [@article]
+    elsif @page
+      [@page]
+    else
+      []
+    end
+  end
+
+  def display_date(date)
+    l(date, format: this_blog.date_format)
+  end
+
+  def display_time(time)
+    time.strftime(this_blog.time_format)
+  end
+
+  def display_date_and_time(timestamp)
+    if this_blog.date_format == 'setting_date_format_distance_of_time_in_words'
+      timeago_tag timestamp, date_only: false
+    else
+      "#{display_date(timestamp)} #{t('helper.at')} #{display_time(timestamp)}"
+    end
+  end
+
+  def show_meta_keyword
+    return unless this_blog.use_meta_keyword
+    meta_tag 'keywords', @keywords unless @keywords.blank?
+  end
+
+  def stop_index_robots?(blog)
+    stop = (params[:year].present? || params[:page].present?)
+    stop = blog.unindex_tags if controller_name == 'tags'
+    stop = blog.unindex_categories if controller_name == 'categories'
+    stop
+  end
+
+  def get_reply_context_url(reply)
+    link_to(reply['user']['name'], reply['user']['entities']['url']['urls'][0]['expanded_url'])
+  rescue
+    link_to(reply['user']['name'], "https://twitter.com/#{reply['user']['name']}")
+  end
+
+  def get_reply_context_twitter_link(reply)
+    link_to(display_date_and_time(reply['created_at'].to_time.in_time_zone),
+            "https://twitter.com/#{reply['user']['screen_name']}/status/#{reply['id_str']}")
+  end
+
+  private
+
+  def feed_for(type)
+    if params[:action] == 'search'
+      url_for(only_path: false, format: type, q: params[:q])
+    elsif !@article.nil?
+      @article.feed_url(type)
+    elsif !@auto_discovery_url_atom.nil?
+      instance_variable_get("@auto_discovery_url_#{type}")
+    end
+  end
+
+  # fetches appropriate html content for RSS and ATOM feeds. Checks for:
+  # - article being password protected
+  # - hiding extended content on RSS. In this case if there is an excerpt we
+  #   show the excerpt, or else we show the body
+  def fetch_html_content_for_feeds(item, this_blog)
+    if item.password_protected?
+      "<p>This article is password protected. Please <a href='#{item.permalink_url}'>fill in your password</a> to read it</p>"
+    elsif this_blog.hide_extended_on_rss
+      if item.excerpt? && !item.excerpt.empty?
+        item.excerpt
+      else
+        html(item, :body)
+      end
+    else
+      html(item, :all)
+    end
+  end
+
+  def nofollowify_links(string)
+    if this_blog.dofollowify
+      string
+    else
+      string.gsub(/<a(.*?)>/i, '<a\1 rel="nofollow">')
+    end
+  end
+
+  def nofollowified_link_to(text, url)
+    if this_blog.dofollowify
+      link_to(text, url)
+    else
+      link_to(text, url, rel: 'nofollow')
+    end
+  end
+end

data/app/helpers/blog_helper.rb

@@ -0,0 +1,12 @@
+module BlogHelper
+  # The base URL for this request, calculated by looking up the URL for the main
+  # blog index page.
+  def blog_base_url
+    url_for(controller: '/articles', action: 'index').gsub(%r{/$}, '')
+  end
+
+  # Find the blog whose base_url matches the current location.
+  def this_blog
+    @blog ||= Blog.find_blog(blog_base_url)
+  end
+end

data/app/helpers/xml_helper.rb

@@ -0,0 +1,16 @@
+module XmlHelper
+  def collection_lastmod(collection)
+    article_updated = collection.articles.order(updated_at: :desc).first
+    article_published = collection.articles.order(published_at: :desc).first
+
+    times = []
+    times.push article_updated.updated_at if article_updated
+    times.push article_published.updated_at if article_published
+
+    if times.empty?
+      Time.at(0).xmlschema
+    else
+      times.max.xmlschema
+    end
+  end
+end

data/app/mailers/notification_mailer.rb

@@ -0,0 +1,38 @@
+class NotificationMailer < ActionMailer::Base
+  helper :base
+  layout nil
+
+  def article(article, user)
+    @user = user
+    @blog = article.blog
+    @article = article
+    build_mail @blog, @user, "New article: #{article.title}"
+  end
+
+  def comment(comment, user)
+    @user = user
+    @blog = comment.blog
+    @comment = comment
+    build_mail @blog, @user, "New comment on #{comment.article.title}"
+  end
+
+  def notif_user(user)
+    @user = user
+    # TODO: Make user blog-dependent
+    @blog = Blog.first
+    build_mail @blog, @user, 'Welcome to Publify'
+  end
+
+  private
+
+  def make_subject(blog, subject)
+    "[#{blog.blog_name}] #{subject}"
+  end
+
+  def build_mail(blog, user, subject)
+    headers['X-Mailer'] = "Publify #{PublifyCore::VERSION}"
+    mail(from: blog.email_from,
+         to: user.email,
+         subject: make_subject(blog, subject))
+  end
+end

data/app/models/ability.rb

@@ -0,0 +1,52 @@
+require 'cancancan'
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    return unless user
+
+    case user.profile
+    when 'admin'
+      add_admin_abilities
+      add_publisher_abilities
+      add_contributor_abilities
+    when 'publisher'
+      add_publisher_abilities
+      add_contributor_abilities
+    when 'contributor'
+      add_contributor_abilities
+    end
+  end
+
+  private
+
+  def add_admin_abilities
+    can :manage, 'admin/cache'
+    can :manage, 'admin/migrations'
+    can :manage, 'admin/seo'
+    can :manage, 'admin/settings'
+    can :manage, 'admin/sidebar'
+    can :manage, 'admin/textfilters'
+    can :manage, 'admin/themes'
+    can :manage, 'admin/users'
+  end
+
+  def add_publisher_abilities
+    can :manage, 'admin/content'
+    can :manage, 'admin/feedback'
+    can :manage, 'admin/notes'
+    can :manage, 'admin/pages'
+    can :manage, 'admin/post_types'
+    can :manage, 'admin/redirects'
+    can :manage, 'admin/resources'
+    can :manage, 'admin/tags'
+
+    can :manage, 'articles'
+  end
+
+  def add_contributor_abilities
+    can :manage, 'admin/dashboard'
+    can :manage, 'admin/profiles'
+  end
+end

data/app/models/archives_sidebar.rb

@@ -0,0 +1,45 @@
+class ArchivesSidebar < Sidebar
+  description 'Displays links to monthly archives'
+  setting :title, 'Archives'
+  setting :show_count, true, label: 'Show article counts', input_type: :checkbox
+  setting :count, 10, label: 'Number of Months'
+
+  attr_accessor :archives
+
+  def self.date_func
+    @date_func ||=
+      begin
+        if Content.connection.is_a?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+          "strftime('%Y', published_at) as year, strftime('%m', published_at) as month"
+        else
+          'extract(year from published_at) as year,extract(month from published_at) as month'
+        end
+      rescue NameError
+        'extract(year from published_at) as year,extract(month from published_at) as month'
+      end
+  end
+
+  def parse_request(_contents, _params)
+    # The original query that was here instantiated every article and every
+    # tag, and then sorted through them just to do a 'group by date'.
+    # Unfortunately, there's no universally-supported way to do this
+    # across all three of our supported DBs.  So, we resort to a bit of
+    # DB-specific code.
+    date_func = self.class.date_func
+
+    article_counts = Content.find_by_sql(["select count(*) as count, #{date_func} from contents where type='Article' and published = ? and published_at < ? group by year,month order by year desc,month desc limit ? ", true, Time.now, count.to_i])
+
+    @archives = article_counts.map do |entry|
+      month = entry.month.to_i
+      year = entry.year.to_i
+      {
+        name: I18n.l(Date.new(year, month), format: '%B %Y'),
+        month: month,
+        year: year,
+        article_count: entry.count
+      }
+    end
+  end
+end
+
+SidebarRegistry.register_sidebar ArchivesSidebar

data/app/models/article/factory.rb

@@ -0,0 +1,56 @@
+class Article::Factory
+  attr_reader :blog, :user
+
+  def initialize(blog, user)
+    @blog = blog
+    @user = user
+  end
+
+  def default
+    blog.articles.build.tap do |art|
+      art.allow_comments = blog.default_allow_comments
+      art.allow_pings = blog.default_allow_pings
+      art.text_filter = user.default_text_filter
+      art.published = true
+    end
+  end
+
+  def get_or_build_from(id)
+    return blog.articles.find(id) if id.present?
+    default
+  end
+
+  def match_permalink_format(path, format)
+    article_params = extract_params(path, format)
+    requested_article(article_params) if article_params
+  end
+
+  def requested_article(params = {})
+    params[:title] ||= params[:article_id]
+    Article.requested_article(params)
+  end
+
+  def extract_params(path, format)
+    specs = format.split('/')
+    specs.delete('')
+    parts = path.split('/')
+    parts.delete('')
+
+    return if parts.length != specs.length
+
+    specs.zip(parts).reduce({}) do |result, (spec, item)|
+      if spec =~ /(.*)%(.*)%(.*)/
+        before_format = Regexp.last_match[1]
+        format_string = Regexp.last_match[2]
+        after_format = Regexp.last_match[3]
+        item =~ /^#{before_format}(.*)#{after_format}$/
+        break unless Regexp.last_match
+        value = Regexp.last_match[1]
+        result[format_string.to_sym] = value
+      elsif spec != item
+        break
+      end
+      result
+    end
+  end
+end

data/app/models/article/states.rb

@@ -0,0 +1,178 @@
+module Article::States
+  class Base < Stateful::State
+    alias content model
+
+    def to_s
+      self.class.to_s.demodulize
+    end
+
+    def exit_hook(_target)
+      ::Rails.logger.debug("#{content} leaving state #{self.class}")
+    end
+
+    def enter_hook
+      ::Rails.logger.debug("#{content} entering state #{self.class}")
+    end
+
+    def post_trigger
+      true
+    end
+
+    def send_notifications
+      true
+    end
+
+    def send_pings
+      true
+    end
+
+    def withdraw
+    end
+  end
+
+  class New < Base
+    def enter_hook
+      super
+      content[:published] = false
+      content[:published_at] = nil
+    end
+
+    def published=(boolean)
+      content.state = :just_published if boolean
+      boolean
+    end
+
+    def published_at=(new_time)
+      unless new_time.nil?
+        content.state = new_time <= Time.new ? :just_published : :publication_pending
+      end
+      content[:published_at] = new_time
+    end
+
+    def draft?
+      true
+    end
+  end
+
+  class JustPublished < Base
+    def enter_hook
+      super
+      content.just_changed_published_status = true
+      content.state = :published
+    end
+  end
+
+  class Published < Base
+    def enter_hook
+      super
+      content[:published] = true
+      content[:published_at] ||= Time.now
+    end
+
+    def published=(boolean)
+      content.state = :just_withdrawn unless boolean
+    end
+
+    def withdraw
+      content.state = :just_withdrawn
+    end
+
+    def published_at=(new_time)
+      return if new_time.blank?
+      content[:published_at] = new_time
+      content.state = :publication_pending if new_time > Time.now
+    end
+
+    def send_notifications
+      content.really_send_notifications if just_published?
+      true
+    end
+
+    def send_pings
+      content.really_send_pings if just_published?
+      true
+    end
+
+    def just_published?
+      content.just_changed_published_status?
+    end
+  end
+
+  class JustWithdrawn < Base
+    def enter_hook
+      super
+      content.just_changed_published_status = true
+      content.state = :withdrawn
+    end
+  end
+
+  class Withdrawn < Base
+    def enter_hook
+      content[:published] = false
+    end
+
+    def published=(boolean)
+      return unless boolean
+      content.state = :published
+    end
+
+    def published_at=(new_time)
+      content[:published_at] = new_time
+      Trigger.remove(content, trigger_method: 'publish!')
+      return if new_time.nil? || new_time <= Time.now
+      content.state = :publication_pending
+    end
+  end
+
+  class PublicationPending < Base
+    def enter_hook
+      content[:published] = false if content.new_record?
+    end
+
+    def published=(published)
+      content[:published] = published
+
+      if published && content.published_at <= Time.now
+        content.state = :just_published
+      end
+    end
+
+    def published_at=(new_time)
+      content[:published_at] = new_time
+      Trigger.remove(content, trigger_method: 'publish!')
+      if new_time.nil?
+        content.state = :draft
+      elsif new_time <= Time.now
+        content.state = :just_published
+      end
+    end
+
+    def post_trigger
+      Trigger.post_action(content.published_at, content, 'publish!')
+    end
+
+    def withdraw(content)
+      content.state = :draft
+    end
+  end
+
+  class Draft < Base
+    def enter_hook
+      super
+      content[:published] = false
+      content[:published_at] = nil
+    end
+
+    def published=(boolean)
+      content.state = :just_published if boolean
+    end
+
+    def published_at=(new_time)
+      # Because of the workings of the controller, we should ignore
+      # publication times before the current time.
+      return if new_time.nil? || new_time <= Time.now
+      content[:published_at] = new_time
+      content.state = :publication_pending
+    end
+  end
+end