HornsAndHooves-publify_core 10.0.0

data/app/controllers/admin/resources_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Admin::ResourcesController < Admin::BaseController
+  def upload
+    file = params[:upload]
+
+    @up = Resource.new(blog: this_blog, upload: file)
+    @up.mime = @up.upload.content_type
+
+    if @up.save
+      flash[:success] = I18n.t("admin.resources.upload.success")
+    else
+      flash[:warning] = I18n.t("admin.resources.upload.warning")
+    end
+
+    redirect_to admin_resources_url
+  end
+
+  def index
+    @r = Resource.new
+    @resources = Resource.order("created_at DESC").page(params[:page]).
+      per(this_blog.admin_display_elements)
+  end
+
+  def destroy
+    if Content.where(resource_id: params[:id]).any?
+      flash[:error] = I18n.t("admin.resources.destroy.error")
+    else
+      @record = Resource.find(params[:id])
+      @record.destroy
+      flash[:notice] = I18n.t("admin.resources.destroy.notice")
+    end
+
+    redirect_to admin_resources_url
+  end
+end

data/app/controllers/admin/seo_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Admin::SeoController < Admin::BaseController
+  before_action :set_setting
+  before_action :set_section
+
+  def show
+    if @setting.permalink_format != "/%year%/%month%/%day%/%title%" &&
+        @setting.permalink_format != "/%year%/%month%/%title%" &&
+        @setting.permalink_format != "/%title%"
+      @setting.custom_permalink = @setting.permalink_format
+      @setting.permalink_format = "custom"
+    end
+  end
+
+  def update
+    if settings_params[:permalink_format] == "custom"
+      settings_params[:permalink_format] = settings_params[:custom_permalink]
+    end
+    if @setting.update(settings_params)
+      flash[:success] = I18n.t("admin.settings.update.success")
+      redirect_to admin_seo_path(section: @section)
+    else
+      flash[:error] = I18n.t("admin.settings.update.error",
+                             messages: this_blog.errors.full_messages.join(", "))
+      render :show
+    end
+  end
+
+  private
+
+  def settings_params
+    @settings_params ||= params.require(:setting).permit!
+  end
+
+  VALID_SECTIONS = %w(general titles permalinks).freeze
+
+  def set_section
+    section = params[:section]
+    @section = VALID_SECTIONS.include?(section) ? section : "general"
+  end
+
+  def set_setting
+    @setting = this_blog
+  end
+end

data/app/controllers/admin/settings_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Admin::SettingsController < Admin::BaseController
+  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(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,67 @@
+# frozen_string_literal: true
+
+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 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&.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!
+    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(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,55 @@
+# frozen_string_literal: true
+
+class Admin::TagsController < Admin::BaseController
+  before_action :fetch_tags, only: [:index, :edit]
+  before_action :set_tag, only: [:edit, :update, :destroy]
+
+  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)
+      # TODO: Check whether these redirects are useful or ignored.
+      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/themes_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "time"
+require "rexml/document"
+
+class Admin::ThemesController < Admin::BaseController
+  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
+    this_blog.current_theme(:reload)
+    flash[:success] = I18n.t("admin.themes.switchto.success")
+    redirect_to admin_themes_url
+  end
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Admin::UsersController < Admin::BaseController
+  before_action :set_user, only: [:edit, :update, :destroy]
+
+  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_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,
+                                 :name, :notify_via_email,
+                                 :notify_on_new_articles, :notify_on_comments,
+                                 :profile, :text_filter_name, :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,215 @@
+# frozen_string_literal: true
+
+class ArticlesController < ContentController
+  RECENT_ARTICLES_COUNT = 3
+
+  before_action :login_required, only: [:preview, :preview_page]
+  before_action :auto_discovery_feed, only: [:show, :index]
+  before_action :verify_config
+  before_action :populate_recent_articles, only: [:redirect, :preview]
+
+  layout :theme_layout, except: [:trackback]
+
+  helper :'admin/base'
+
+  def index
+    wanted_types = this_blog.statuses_in_timeline ? ["Article", "Note"] : ["Article"]
+
+    limit = this_blog.per_page(params[:format])
+    articles_base = if params[:year].blank?
+                      this_blog.contents.published
+                    else
+                      this_blog.contents.published_at(params.values_at(:year, :month, :day))
+                    end
+    @articles = articles_base.includes(:user, :resources, :tags).
+      where(type: wanted_types).page(params[:page]).per(limit)
+
+    respond_to do |format|
+      format.html do
+        set_index_title_and_description(this_blog, params)
+        @keywords = this_blog.meta_keywords
+
+        render_paginated_index
+      end
+      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_articles_feed "rss" }
+      format.atom { render_articles_feed "atom" }
+    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)
+      if @article
+        return redirect_to URI.parse(@article.permalink_url).path,
+                           status: :moved_permanently
+      end
+    end
+
+    r = Redirect.find_by!(from_path: from)
+    # TODO: If linked to article, directly redirect to the article.
+    # Let redirection made outside of the blog on purpose (deal with it, Brakeman!)
+    redirect_to r.full_to_path, status: :moved_permanently if r
+  end
+
+  def archives
+    limit = this_blog.limit_archives_display
+    @articles = this_blog.published_articles.includes(:tags).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: :moved_permanently
+  end
+
+  def preview_page
+    @page = Page.find(params[:id])
+    render "view_page"
+  end
+
+  def view_page
+    @page = Page.published.find_by!(name: Array(params[:name]).join("/"))
+    @page_title = @page.title
+    @description = this_blog.meta_description
+    @keywords = this_blog.meta_keywords
+  end
+
+  # TODO: Move to TextfilterController?
+  def markup_help
+    render html: TextFilter.make_filter(params[:id]).commenthelp
+  end
+
+  private
+
+  def set_index_title_and_description(blog, parameters)
+    @page_title = blog.home_title_template
+    @description = blog.home_desc_template
+    if parameters[:year]
+      @page_title = blog.archives_title_template
+      @description = blog.archives_desc_template
+    elsif parameters[:page]
+      @page_title = blog.paginated_title_template
+      @description = blog.paginated_desc_template
+    end
+    @page_title = @page_title.to_title(@articles, blog, parameters)
+    @description = @description.to_title(@articles, blog, parameters)
+  end
+
+  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
+
+  private def populate_recent_articles
+    @recent_articles = this_blog.contents.published.limit(RECENT_ARTICLES_COUNT)
+  end
+
+  # See an article We need define @article before
+  def show_article
+    auto_discovery_feed
+    respond_to do |format|
+      format.html do
+        @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)
+
+        @keywords = @article.tags.map(&:name).join(", ")
+        render "articles/#{@article.post_type}"
+      end
+      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)
+    render_cached_xml("index_#{format}_feed", @articles)
+  end
+
+  def render_feedback_feed(format)
+    render_cached_xml("feedback_#{format}_feed", @article)
+  end
+
+  def render_paginated_index
+    return error! if @articles.empty?
+
+    auto_discovery_feed(only_path: false)
+    render "index"
+  end
+
+  def extract_feed_format(from)
+    if /^.*\.rss$/.match?(from)
+      request.format = "rss"
+      from = from.gsub(/\.rss/, "")
+    elsif /^.*\.atom$/.match?(from)
+      request.format = "atom"
+      from = from.gsub(/\.atom$/, "")
+    end
+    from
+  end
+
+  def error!
+    @message = I18n.t("errors.no_posts_found")
+    render "articles/error", status: :ok
+  end
+end

data/app/controllers/authors_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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,43 @@
+# frozen_string_literal: true
+
+require "cancancan"
+
+class BaseController < ApplicationController
+  before_action :fire_triggers, :load_lang, :set_paths
+
+  private
+
+  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