publify_core 9.0.0.pre1

data/app/controllers/admin/settings_controller.rb

@@ -0,0 +1,53 @@
+class Admin::SettingsController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+
+  def index
+    this_blog.base_url = blog_base_url if this_blog.base_url.blank?
+    load_settings
+  end
+
+  def write
+    load_settings
+  end
+
+  def feedback
+    load_settings
+  end
+
+  def display
+    load_settings
+  end
+
+  def update
+    load_settings
+    if @setting.update_attributes(settings_params)
+      load_lang
+      flash[:success] = I18n.t('admin.settings.update.success')
+      redirect_to action: action_param
+    else
+      flash[:error] = I18n.t('admin.settings.update.error',
+                             messages: this_blog.errors.full_messages.join(', '))
+      render action_param
+    end
+  end
+
+  private
+
+  VALID_ACTIONS = %w(index write feedback display).freeze
+
+  def settings_params
+    @settings_params ||= params.require(:setting).permit!
+  end
+
+  def action_param
+    @action_param ||=
+      begin
+        value = params[:from]
+        VALID_ACTIONS.include?(value) ? value : 'index'
+      end
+  end
+
+  def load_settings
+    @setting = this_blog
+  end
+end

data/app/controllers/admin/sidebar_controller.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+class Admin::SidebarController < Admin::BaseController
+  def index
+    @available = SidebarRegistry.available_sidebars
+    @ordered_sidebars = Sidebar.ordered_sidebars
+  end
+
+  # Just update a single active Sidebar instance at once
+  def update
+    @sidebar = Sidebar.where(id: params[:id]).first
+    @old_s_index = @sidebar.staged_position || @sidebar.active_position
+    @sidebar.update_attributes params[:configure][@sidebar.id.to_s].permit!
+    respond_to do |format|
+      format.js
+      format.html do
+        return redirect_to(admin_sidebar_index_path)
+      end
+    end
+  end
+
+  def destroy
+    @sidebar = Sidebar.where(id: params[:id]).first
+    @sidebar && @sidebar.destroy
+    respond_to do |format|
+      format.html { return redirect_to(admin_sidebar_index_path) }
+      format.js
+    end
+  end
+
+  def publish
+    Sidebar.apply_staging_on_active!
+    PageCache.sweep_all
+    redirect_to admin_sidebar_index_path
+  end
+
+  # Callback for admin sidebar sortable plugin
+  def sortable
+    sorted = params[:sidebar].map(&:to_i)
+
+    Sidebar.transaction do
+      sorted.each_with_index do |sidebar_id, staged_index|
+        # DEV NOTE : Ok, that's a HUGE hack. Sidebar.available are Class, not
+        # Sidebar instances. In order to use jQuery.sortable we need that hack:
+        # Sidebar.available is an Array, so it's ordered. I arbitrary shift by?
+        # IT'S OVER NINE THOUSAND! considering we'll never reach 9K Sidebar
+        # instances or Sidebar specializations
+        sidebar = if sidebar_id >= 9000
+                    SidebarRegistry.available_sidebars[sidebar_id - 9000].new(blog: this_blog)
+                  else
+                    Sidebar.valid.find(sidebar_id)
+                  end
+        sidebar.update_attributes(staged_position: staged_index)
+      end
+    end
+
+    @ordered_sidebars = Sidebar.ordered_sidebars
+    @available = SidebarRegistry.available_sidebars
+
+    respond_to do |format|
+      format.js
+      format.html do
+        return redirect_to admin_sidebar_index_path
+      end
+    end
+  end
+end

data/app/controllers/admin/tags_controller.rb

@@ -0,0 +1,53 @@
+class Admin::TagsController < Admin::BaseController
+  before_action :fetch_tags, only: [:index, :edit]
+  before_action :set_tag, only: [:edit, :update, :destroy]
+  cache_sweeper :blog_sweeper
+
+  def index
+    @tag = Tag.new
+  end
+
+  def edit
+  end
+
+  def create
+    @tag = this_blog.tags.new(tag_params)
+
+    if @tag.save
+      redirect_to admin_tags_url, notice: 'Tag was successfully created.'
+    else
+      fetch_tags
+      render :index
+    end
+  end
+
+  def update
+    old_name = @tag.name
+    if @tag.update(tag_params)
+      Redirect.create(from_path: "/tag/#{old_name}", to_path: @tag.permalink_url(nil, true))
+      redirect_to admin_tags_url, notice: I18n.t('admin.tags.edit.success')
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    destroy_a(Tag)
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  def set_tag
+    @tag = Tag.find(params[:id])
+  end
+
+  # Never trust parameters from the scary internet, only allow the white list through.
+  def tag_params
+    params.require(:tag).permit(:display_name)
+  end
+
+  def fetch_tags
+    @tags = Tag.order('display_name').page(params[:page]).per(this_blog.admin_display_elements)
+  end
+end

data/app/controllers/admin/textfilters_controller.rb

@@ -0,0 +1,6 @@
+class Admin::TextfiltersController < Admin::BaseController
+  def macro_help
+    @macro = TextFilterPlugin.available_filters.find { |filter| filter.short_name == params[:id] }
+    render text: BlueCloth.new(@macro.help_text).to_html
+  end
+end

data/app/controllers/admin/themes_controller.rb

@@ -0,0 +1,37 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+class Admin::ThemesController < Admin::BaseController
+  cache_sweeper :blog_sweeper
+
+  def index
+    @themes = Theme.find_all
+    @themes.each do |theme|
+      # TODO: Move to Theme
+      theme.description_html = TextFilter.filter_text(theme.description, [:markdown, :smartypants])
+    end
+    @active = this_blog.current_theme
+  end
+
+  def preview
+    theme = Theme.find(params[:theme])
+    send_file File.join(theme.path, 'preview.png'),
+              type: 'image/png', disposition: 'inline', stream: false
+  end
+
+  def switchto
+    this_blog.theme = params[:theme]
+    this_blog.save
+    zap_theme_caches
+    this_blog.current_theme(:reload)
+    flash[:success] = I18n.t('admin.themes.switchto.success')
+    redirect_to admin_themes_url
+  end
+
+  protected
+
+  def zap_theme_caches
+    FileUtils.rm_rf(%w(stylesheets javascript images).map { |v| page_cache_directory + "/#{v}/theme" })
+  end
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,65 @@
+class Admin::UsersController < Admin::BaseController
+  before_action :set_user, only: [:edit, :update, :destroy]
+  cache_sweeper :blog_sweeper
+
+  def index
+    @users = User.order('login asc').page(params[:page]).per(this_blog.admin_display_elements)
+  end
+
+  def new
+    @user = User.new
+    @user.text_filter = TextFilter.find_by(name: this_blog.text_filter)
+  end
+
+  def edit
+    @user = params[:id] ? User.find_by(id: params[:id]) : current_user
+  end
+
+  def create
+    @user = User.new(user_params)
+    @user.name = @user.login
+    if @user.save
+      redirect_to admin_users_url, notice: I18n.t('admin.users.new.success')
+    else
+      render :new
+    end
+  end
+
+  def update
+    if @user.update(update_params)
+      redirect_to admin_users_url, notice: 'User was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @user.destroy if User.where('profile = ? and id != ?', User::ADMIN, @user.id).count > 1
+    redirect_to admin_users_url
+  end
+
+  private
+
+  def set_user
+    @user = User.find(params[:id])
+  end
+
+  def user_params
+    params.require(:user).permit(:login, :password, :password_confirmation,
+                                 :email, :firstname, :lastname, :nickname,
+                                 :display_name, :notify_via_email,
+                                 :notify_on_new_articles, :notify_on_comments,
+                                 :profile, :text_filter, :state,
+                                 :twitter_account, :twitter_oauth_token,
+                                 :twitter_oauth_token_secret, :description,
+                                 :url, :msn, :yahoo, :jabber, :aim, :twitter)
+  end
+
+  def update_params
+    if user_params[:password].blank? && user_params[:password_confirmation].blank?
+      user_params.except(:password_confirmation, :password)
+    else
+      user_params
+    end
+  end
+end

data/app/controllers/articles_controller.rb

@@ -0,0 +1,205 @@
+class ArticlesController < ContentController
+  before_action :login_required, only: [:preview, :preview_page]
+  before_action :auto_discovery_feed, only: [:show, :index]
+  before_action :verify_config
+
+  layout :theme_layout, except: [:trackback]
+
+  cache_sweeper :blog_sweeper
+  caches_page :index, :archives, :read, :view_page, :redirect, if: proc { |c| c.request.query_string == '' }
+
+  helper :'admin/base'
+
+  def index
+    conditions = this_blog.statuses_in_timeline ? ['type in (?, ?)', 'Article', 'Note'] : ['type = ?', 'Article']
+
+    limit = this_blog.per_page(params[:format])
+    @articles = if params[:year].blank?
+                  this_blog.contents.published.where(conditions).page(params[:page]).per(limit)
+                else
+                  this_blog.contents.published_at(params.values_at(:year, :month, :day)).where(conditions).page(params[:page]).per(limit)
+                end
+
+    @page_title = this_blog.home_title_template
+    @description = this_blog.home_desc_template
+    if params[:year]
+      @page_title = this_blog.archives_title_template
+      @description = this_blog.archives_desc_template
+    elsif params[:page]
+      @page_title = this_blog.paginated_title_template
+      @description = this_blog.paginated_desc_template
+    end
+    @page_title = @page_title.to_title(@articles, this_blog, params)
+    @description = @description.to_title(@articles, this_blog, params)
+
+    @keywords = this_blog.meta_keywords
+
+    respond_to do |format|
+      format.html { render_paginated_index }
+      format.atom do
+        render_articles_feed('atom')
+      end
+      format.rss do
+        auto_discovery_feed(only_path: false)
+        render_articles_feed('rss')
+      end
+    end
+  end
+
+  def search
+    @articles = this_blog.articles_matching(params[:q], page: params[:page], per_page: this_blog.per_page(params[:format]))
+    return error! if @articles.empty?
+    @page_title = this_blog.search_title_template.to_title(@articles, this_blog, params)
+    @description = this_blog.search_desc_template.to_title(@articles, this_blog, params)
+    respond_to do |format|
+      format.html { render 'search' }
+      format.rss { render 'index_rss_feed', layout: false }
+      format.atom { render 'index_atom_feed', layout: false }
+    end
+  end
+
+  def live_search
+    @search = params[:q]
+    @articles = Article.search(@search)
+    render :live_search, layout: false
+  end
+
+  def preview
+    @article = Article.last_draft(params[:id])
+    @page_title = this_blog.article_title_template.to_title(@article, this_blog, params)
+    render 'read'
+  end
+
+  def check_password
+    return unless request.xhr?
+    @article = Article.find(params[:article][:id])
+    if @article.password == params[:article][:password]
+      render partial: 'articles/full_article_content', locals: { article: @article }
+    else
+      render partial: 'articles/password_form', locals: { article: @article }
+    end
+  end
+
+  def redirect
+    from = extract_feed_format(params[:from])
+    factory = Article::Factory.new(this_blog, current_user)
+
+    @article = factory.match_permalink_format(from, this_blog.permalink_format)
+    return show_article if @article
+
+    # Redirect old version with /:year/:month/:day/:title to new format,
+    # because it's changed
+    ['%year%/%month%/%day%/%title%', 'articles/%year%/%month%/%day%/%title%'].each do |part|
+      @article = factory.match_permalink_format(from, part)
+      return redirect_to URI.parse(@article.permalink_url).path, status: 301 if @article
+    end
+
+    r = Redirect.find_by(from_path: from)
+    return redirect_to r.full_to_path, status: 301 if r # Let redirection made outside of the blog on purpose (deal with it, Brakeman!)
+
+    render 'errors/404', status: 404
+  end
+
+  def archives
+    limit = this_blog.limit_archives_display
+    @articles = this_blog.published_articles.page(params[:page]).per(limit)
+    @page_title = this_blog.archives_title_template.to_title(@articles, this_blog, params)
+    @keywords = this_blog.meta_keywords
+    @description = this_blog.archives_desc_template.to_title(@articles, this_blog, params)
+  end
+
+  def tag
+    redirect_to tags_path, status: 301
+  end
+
+  def preview_page
+    @page = Page.find(params[:id])
+    render 'view_page'
+  end
+
+  def view_page
+    if (@page = Page.find_by(name: Array(params[:name]).join('/'))) && @page.published?
+      @page_title = @page.title
+      @description = this_blog.meta_description
+      @keywords = this_blog.meta_keywords
+    else
+      render 'errors/404', status: 404
+    end
+  end
+
+  # TODO: Move to TextfilterController?
+  def markup_help
+    render text: TextFilter.find(params[:id]).commenthelp
+  end
+
+  private
+
+  def verify_config
+    if !this_blog.configured?
+      redirect_to controller: 'setup', action: 'index'
+    elsif User.count == 0
+      redirect_to new_user_registration_path
+    else
+      true
+    end
+  end
+
+  # See an article We need define @article before
+  def show_article
+    @comment = Comment.new
+    @page_title = this_blog.article_title_template.to_title(@article, this_blog, params)
+    @description = this_blog.article_desc_template.to_title(@article, this_blog, params)
+    groupings = @article.tags
+    @keywords = groupings.map(&:name).join(', ')
+
+    auto_discovery_feed
+    respond_to do |format|
+      format.html { render "articles/#{@article.post_type}" }
+      format.atom { render_feedback_feed('atom') }
+      format.rss { render_feedback_feed('rss') }
+      format.xml { render_feedback_feed('atom') }
+    end
+  rescue ActiveRecord::RecordNotFound
+    error!
+  end
+
+  def render_articles_feed(format)
+    if this_blog.feedburner_url.empty? || request.env['HTTP_USER_AGENT'] =~ /FeedBurner/i
+      render "index_#{format}_feed", layout: false
+    else
+      redirect_to "http://feeds2.feedburner.com/#{this_blog.feedburner_url}"
+    end
+  end
+
+  def render_feedback_feed(format)
+    @feedback = @article.published_feedback
+    render "feedback_#{format}_feed", layout: false
+  end
+
+  def render_paginated_index
+    return error! if @articles.empty?
+    if this_blog.feedburner_url.empty?
+      auto_discovery_feed(only_path: false)
+    else
+      @auto_discovery_url_rss = "http://feeds2.feedburner.com/#{this_blog.feedburner_url}"
+      @auto_discovery_url_atom = "http://feeds2.feedburner.com/#{this_blog.feedburner_url}"
+    end
+    render 'index'
+  end
+
+  def extract_feed_format(from)
+    if from =~ /^.*\.rss$/
+      request.format = 'rss'
+      from = from.gsub(/\.rss/, '')
+    elsif from =~ /^.*\.atom$/
+      request.format = 'atom'
+      from = from.gsub(/\.atom$/, '')
+    end
+    from
+  end
+
+  def error!
+    @message = I18n.t('errors.no_posts_found')
+    render 'articles/error', status: 200
+  end
+end

data/app/controllers/authors_controller.rb

@@ -0,0 +1,27 @@
+class AuthorsController < ContentController
+  layout :theme_layout
+
+  def show
+    @author = User.find_by(login: params[:id])
+    raise ActiveRecord::RecordNotFound unless @author
+
+    @articles = @author.articles.published.page(params[:page]).per(this_blog.per_page(params[:format]))
+    @page_title = this_blog.author_title_template.to_title(@author, this_blog, params)
+    @keywords = this_blog.meta_keywords
+    @description = this_blog.author_desc_template.to_title(@author, this_blog, params)
+
+    auto_discovery_feed(only_path: false)
+
+    respond_to do |format|
+      format.rss { render_feed 'rss' }
+      format.atom { render_feed 'atom' }
+      format.html
+    end
+  end
+
+  private
+
+  def render_feed(format)
+    render "show_#{format}_feed", layout: false
+  end
+end

data/app/controllers/base_controller.rb

@@ -0,0 +1,45 @@
+require 'cancancan'
+
+class BaseController < ApplicationController
+  before_action :fire_triggers, :load_lang, :set_paths
+  before_action :configure_permitted_parameters, if: :devise_controller?
+
+  private
+
+  def configure_permitted_parameters
+    # TODO: Check if this is still needed
+    devise_parameter_sanitizer.permit(:sign_up, keys: [:email])
+  end
+
+  def login_required
+    authenticate_user! && authorize!(params[:action], params[:controller])
+  end
+
+  def set_paths
+    prepend_view_path this_blog.current_theme.view_path
+    Dir.glob(File.join(::Rails.root.to_s, 'lib', '*_sidebar/app/views')).select do |file|
+      append_view_path file
+    end
+  end
+
+  def fire_triggers
+    Trigger.fire
+  end
+
+  def load_lang
+    if I18n.available_locales.include?(this_blog.lang.to_sym)
+      I18n.locale = this_blog.lang
+    elsif I18n.available_locales.include?(this_blog.lang[0..1].to_sym)
+      I18n.locale = this_blog.lang[0..1]
+    # for the same language used in different areas, e.g. zh_CN, zh_TW
+    elsif I18n.available_locales.include?(this_blog.lang.sub('_', '-').to_sym)
+      I18n.locale = this_blog.lang.sub('_', '-')
+    end
+  end
+
+  def add_to_cookies(name, value, path = nil, _expires = nil)
+    cookies[name] = { value: value, path: path || "/#{controller_name}", expires: 6.weeks.from_now }
+  end
+
+  include BlogHelper
+end

data/app/controllers/comments_controller.rb

@@ -0,0 +1,69 @@
+class CommentsController < FeedbackController
+  before_action :get_article, only: [:create, :preview]
+
+  def create
+    @comment = @article.with_options(new_comment_defaults) do |art|
+      art.add_comment(params[:comment].slice(:body, :author, :email, :url))
+    end
+
+    unless current_user.nil? || session[:user_id].nil?
+      # maybe useless, but who knows ?
+      @comment.user_id = current_user.id if current_user.id == session[:user_id]
+    end
+
+    set_cookies_for @comment
+
+    partial = '/articles/comment_failed'
+    if recaptcha_ok_for?(@comment) && @comment.save
+      partial = '/articles/comment'
+    end
+    respond_to do |format|
+      format.js { render partial }
+      format.html { redirect_to URI.parse(@article.permalink_url).path }
+    end
+  end
+
+  def preview
+    return render text: 'Comments are closed' if @article.comments_closed?
+
+    if comment_params[:body].blank?
+      render nothing: true
+      return
+    end
+
+    @comment = Comment.new(comment_params)
+  end
+
+  protected
+
+  def recaptcha_ok_for?(comment)
+    use_recaptcha = comment.blog.use_recaptcha
+    ((use_recaptcha && verify_recaptcha(model: comment)) || !use_recaptcha)
+  end
+
+  def new_comment_defaults
+    { ip: request.remote_ip,
+      author: 'Anonymous',
+      published: true,
+      user: @current_user,
+      user_agent: request.env['HTTP_USER_AGENT'],
+      referrer: request.env['HTTP_REFERER'],
+      permalink: @article.permalink_url }.stringify_keys
+  end
+
+  def set_cookies_for(comment)
+    add_to_cookies(:author, comment.author)
+    add_to_cookies(:url, comment.url)
+    unless comment.email.blank?
+      add_to_cookies(:gravatar_id, Digest::MD5.hexdigest(comment.email.strip))
+    end
+  end
+
+  def get_article
+    @article = Article.find(params[:article_id])
+  end
+
+  def comment_params
+    @comment_params ||= params.require(:comment).permit(:body, :author, :email, :url)
+  end
+end

data/app/controllers/content_controller.rb

@@ -0,0 +1,31 @@
+class ContentController < BaseController
+  class ExpiryFilter
+    def before(_controller)
+      @request_time = Time.now
+    end
+
+    def after(controller)
+      future_article =
+        this_blog.articles.where('published = ? AND published_at > ?', true, @request_time).
+          order('published_at ASC').first
+      if future_article
+        delta = future_article.published_at - Time.now
+        controller.response.lifetime = delta <= 0 ? 0 : delta
+      end
+    end
+  end
+
+  protected
+
+  # TODO: Make this work for all content.
+  def auto_discovery_feed(options = {})
+    with_options(options.reverse_merge(only_path: true)) do |opts|
+      @auto_discovery_url_rss = opts.url_for(format: 'rss', only_path: false)
+      @auto_discovery_url_atom = opts.url_for(format: 'atom', only_path: false)
+    end
+  end
+
+  def theme_layout
+    this_blog.current_theme.layout(action_name)
+  end
+end