HornsAndHooves-publify_core 10.0.0

data/app/controllers/comments_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class CommentsController < BaseController
+  before_action :set_article, only: [:create, :preview]
+
+  def create
+    options = new_comment_defaults.merge comment_params.to_h
+    @comment = @article.add_comment(options)
+
+    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
+
+    remember_author_info_for @comment
+
+    partial = "/articles/comment_failed"
+    partial = "/articles/comment" if recaptcha_ok_for?(@comment) && @comment.save
+    respond_to do |format|
+      format.js { render partial }
+      format.html { redirect_to URI.parse(@article.permalink_url).path }
+    end
+  end
+
+  def preview
+    return render plain: "Comments are closed" if @article.comments_closed?
+
+    if comment_params[:body].blank?
+      head :ok
+      return
+    end
+
+    @comment = @article.comments.build(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",
+      user: @current_user,
+      user_agent: request.env["HTTP_USER_AGENT"],
+      referrer: request.env["HTTP_REFERER"],
+      permalink: @article.permalink_url }.stringify_keys
+  end
+
+  def remember_author_info_for(comment)
+    add_to_cookies(:author, comment.author)
+    add_to_cookies(:url, comment.url)
+    if comment.email.present?
+      add_to_cookies(:gravatar_id, Digest::MD5.hexdigest(comment.email.strip))
+    end
+  end
+
+  def set_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,24 @@
+# frozen_string_literal: true
+
+class ContentController < BaseController
+  private
+
+  # 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
+
+  def render_cached_xml(template, object)
+    feed = cache([controller_name, template, object]) do
+      render_to_string template, layout: false
+    end
+    render xml: feed
+  end
+end

data/app/controllers/feedback_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class FeedbackController < BaseController
+  def index
+    @feedback = Feedback.ham.
+      newest_first.
+      limit(this_blog.per_page(params[:format]))
+    respond_to do |format|
+      format.atom { render "index", format: "atom" }
+      format.rss { render "index", format: "rss" }
+    end
+  end
+end

data/app/controllers/notes_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class NotesController < ContentController
+  require "json"
+
+  layout :theme_layout
+
+  after_action :set_blog_infos
+
+  def index
+    @notes = Note.published.page(params[:page]).per(this_blog.limit_article_display)
+
+    if @notes.empty?
+      @message = I18n.t("errors.no_notes_found")
+      render "notes/error", status: :ok
+    end
+  end
+
+  def show
+    @note = Note.published.find_by! permalink: CGI.escape(params[:permalink])
+
+    if @note.in_reply_to_message.present?
+      @reply = JSON.parse(@note.in_reply_to_message)
+      render :show_in_reply
+    end
+  end
+
+  private
+
+  def set_blog_infos
+    @keywords = this_blog.meta_keywords
+    @page_title = this_blog.statuses_title_template.to_title(@notes, this_blog, params)
+    @description = this_blog.statuses_desc_template.to_title(@notes, this_blog, params)
+  end
+end

data/app/controllers/setup_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class SetupController < BaseController
+  before_action :check_config
+  layout "accounts"
+
+  def index; end
+
+  def create
+    this_blog.blog_name = params[:setting][:blog_name]
+    this_blog.base_url = blog_base_url
+
+    @user = User.new(login: "admin",
+                     email: params[:setting][:email],
+                     password: params[:setting][:password],
+                     text_filter_name: this_blog.text_filter,
+                     nickname: "Publify Admin")
+    @user.name = @user.login
+
+    unless this_blog.save && @user.save
+      redirect_to setup_url
+      return
+    end
+
+    sign_in @user
+
+    # if User.count == 1
+    #   create_first_post @user
+    #   create_first_page @user
+    # end
+
+    # EmailNotify.send_user_create_notification(@user)
+
+    redirect_to confirm_accounts_url
+  end
+
+  private
+
+  def create_first_post(user)
+    this_blog.articles.build(title: I18n.t("setup.article.title"),
+                             author: user.login,
+                             body: I18n.t("setup.article.body"),
+                             allow_comments: 1,
+                             allow_pings: 1,
+                             user: user).publish!
+  end
+
+  def create_first_page(user)
+    this_blog.pages.create(name: "about",
+                           state: "published",
+                           title: I18n.t("setup.page.about"),
+                           user: user,
+                           body: I18n.t("setup.page.body"))
+  end
+
+  def check_config
+    return unless this_blog.configured?
+
+    redirect_to controller: "articles", action: "index"
+  end
+end

data/app/controllers/tags_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class TagsController < ContentController
+  before_action :auto_discovery_feed, only: [:show, :index]
+  layout :theme_layout
+
+  def index
+    @tags = Tag.page(params[:page]).per(100)
+    @page_title = controller_name.capitalize
+    @keywords = ""
+    @description = "Tags for #{this_blog.blog_name}"
+  end
+
+  def show
+    @tag = Tag.find_by!(name: params[:id])
+
+    @articles = @tag.
+      contents.includes(:blog, :user, :tags, :resources).
+      published.page(params[:page]).per(10)
+
+    respond_to do |format|
+      format.html do
+        if @articles.empty?
+          raise ActiveRecord::RecordNotFound
+        else
+          @page_title = this_blog.tag_title_template.to_title(@tag, this_blog, params).strip
+          @description = this_blog.tag_desc_template.to_title(@tag, this_blog, params).strip
+          @keywords = this_blog.meta_keywords
+          render "articles/index"
+        end
+      end
+
+      format.atom do
+        @articles = @articles[0, this_blog.limit_rss_display]
+        render_cached_xml "articles/index_atom_feed", @articles
+      end
+
+      format.rss do
+        @articles = @articles[0, this_blog.limit_rss_display]
+        render_cached_xml "articles/index_rss_feed", @articles
+      end
+    end
+  end
+
+  private
+
+  def template_name(value)
+    template_exists?("tags/#{value}") ? value : :show
+  end
+end

data/app/controllers/text_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TextController < BaseController
+  def robots
+    render plain: this_blog.robots
+  end
+end

data/app/controllers/textfilter_controller.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# TODO: Remove
+class TextfilterController < BaseController
+end

data/app/controllers/theme_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class ThemeController < ContentController
+  # Allow javascripts via Get request
+  skip_before_action :verify_authenticity_token, only: :javascripts
+
+  def stylesheets
+    render_theme_item(:stylesheets, params[:filename], "text/css; charset=utf-8")
+  end
+
+  def javascripts
+    render_theme_item(:javascripts, params[:filename], "text/javascript; charset=utf-8")
+  end
+
+  def images
+    render_theme_item(:images, params[:filename])
+  end
+
+  def fonts
+    render_theme_item(:fonts, params[:filename])
+  end
+
+  def error
+    head :not_found
+  end
+
+  def static_view_test; end
+
+  private
+
+  def render_theme_item(type, file, mime = nil)
+    return render_not_found if file.split(%r{[\\/]}).include?("..")
+
+    src = this_blog.current_theme.path + "/#{type}/#{file}"
+    return render_not_found unless File.exist? src
+
+    mime ||= mime_for(file)
+    send_file(src, type: mime, disposition: "inline", stream: true)
+  end
+
+  def render_not_found
+    render plain: "Not Found", status: :not_found
+  end
+
+  def mime_for(filename)
+    case filename.downcase
+    when /\.js$/
+      "text/javascript"
+    when /\.css$/
+      "text/css"
+    when /\.gif$/
+      "image/gif"
+    when /(\.jpg|\.jpeg)$/
+      "image/jpeg"
+    when /\.png$/
+      "image/png"
+    when /\.swf$/
+      "application/x-shockwave-flash"
+    else
+      "application/binary"
+    end
+  end
+end

data/app/controllers/xml_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class XmlController < BaseController
+  def sitemap
+    @items = []
+    @blog = this_blog
+
+    @feed_title = this_blog.blog_name
+    @link = this_blog.base_url
+    @self_url = request.url
+
+    @items += Article.find_already_published(1000)
+    @items += Page.find_already_published(1000)
+    @items += Tag.find_all_with_content_counters unless this_blog.unindex_tags
+
+    respond_to do |format|
+      format.googlesitemap
+    end
+  end
+end

data/app/helpers/admin/base_helper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Admin::BaseHelper
+  include ActionView::Helpers::DateHelper
+
+  def toggle_element(element, label = t("generic.change"))
+    link_to label, "##{element}", data: { toggle: :collapse }
+  end
+
+  def class_for_admin_state(sidebar, this_position)
+    case sidebar.admin_state
+    when :active
+      "active alert-info"
+    when :will_change_position
+      if this_position == sidebar.active_position
+        "will_change ghost"
+      else
+        "will_change alert-warning"
+      end
+    else
+      raise sidebar.admin_state.inspect
+    end
+  end
+
+  def text_filter_options
+    TextFilter.all.map do |filter|
+      [filter.description, filter.name]
+    end
+  end
+
+  def plugin_options(kind)
+    PublifyPlugins::Keeper.available_plugins(kind).map do |plugin|
+      [plugin.name, plugin.to_s]
+    end
+  end
+
+  def show_actions(item)
+    content_tag(:div, class: "action", style: "") do
+      safe_join [button_to_edit(item),
+                 button_to_delete(item),
+                 button_to_short_url(item)], " "
+    end
+  end
+
+  def display_pagination(collection, cols, _first = "", _last = "")
+    return if collection.count == 0
+
+    content_tag(:tr) do
+      content_tag(:td, paginate(collection), class: "paginate", colspan: cols)
+    end
+  end
+
+  def button_to_edit(item)
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-pencil"),
+            { action: "edit", id: item.id },
+            { class: "btn btn-primary btn-xs btn-action" })
+  end
+
+  def button_to_delete(item)
+    confirm_text = t("admin.shared.destroy.are_you_sure",
+                     element: item.class.name.downcase)
+    link_to(
+      content_tag(:span, "", class: "glyphicon glyphicon-trash"),
+      { action: "destroy", id: item.id },
+      { class: "btn btn-danger btn-xs btn-action", method: :delete,
+        data: { confirm: confirm_text } })
+  end
+
+  def button_to_short_url(item)
+    return "" if item.short_url.nil?
+
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-link"), item.short_url,
+            class: "btn btn-success btn-xs btn-action")
+  end
+
+  def twitter_available?(blog, user)
+    blog.has_twitter_configured? && user.has_twitter_configured?
+  end
+
+  def menu_item(name, url)
+    if current_page? url
+      content_tag(:li, link_to(name, "#"), class: "active")
+    else
+      content_tag(:li, link_to(name, url))
+    end
+  end
+end

data/app/helpers/admin/feedback_helper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Admin::FeedbackHelper
+  def comment_class(state)
+    return "label-info" if state.to_s.casecmp("presumed_ham").zero?
+    return "label-warning" if state.to_s.casecmp("presumed_spam").zero?
+    return "label-success" if state.to_s.casecmp("ham").zero?
+
+    "label-danger"
+  end
+
+  def show_feedback_actions(item, context = "listing")
+    return unless can? :manage, "admin/feedback"
+
+    content_tag(:div, class: "action", style: "") do
+      safe_join [
+        content_tag(:small, change_status(item, context)),
+        button_to_edit_comment(item),
+        button_to_delete_comment(item),
+        button_to_conversation(item),
+      ], " "
+    end
+  end
+
+  def button_to_edit_comment(item)
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-pencil"),
+            { controller: "admin/feedback", action: "edit", id: item.id },
+            { class: "btn btn-primary btn-xs btn-action" })
+  end
+
+  def button_to_delete_comment(item)
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-trash"),
+            { controller: "admin/feedback", action: "destroy", id: item.id },
+            { class: "btn btn-danger btn-xs btn-action" })
+  end
+
+  def button_to_conversation(item)
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-share-alt"),
+            { controller: "admin/feedback", action: "article", id: item.article_id },
+            { class: "btn btn-default btn-xs btn-action" })
+  end
+
+  def change_status(item, context = "listing")
+    spammy = item.state.to_s.downcase =~ /spam/
+    direction = spammy ? "up" : "down"
+    button_type = spammy ? "success" : "warning"
+
+    link_to(content_tag(:span, "", class: "glyphicon glyphicon-thumbs-#{direction}"),
+            { controller: "admin/feedback", action: "change_state",
+              id: item.id, context: context },
+            { class: "btn btn-#{button_type} btn-xs btn-action", remote: true })
+  end
+end

data/app/helpers/articles_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ArticlesHelper
+  def tag_links(article)
+    tag_arr = article.tags.map do |tag|
+      link_to tag.display_name, tag.permalink_url(nil, true), rel: "tag"
+    end
+    safe_join(tag_arr.sort, ", ")
+  end
+end

data/app/helpers/authors_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AuthorsHelper
+  include BlogHelper
+
+  def display_profile_item(item, item_desc)
+    return if item.blank?
+
+    item = link_to(item, item) if is_url?(item)
+    content_tag :li do
+      safe_join([item_desc, item], " ")
+    end
+  end
+
+  def is_url?(str)
+    [URI::HTTP, URI::HTTPS].include?(URI.parse(str.to_s).class)
+  rescue URI::InvalidURIError
+    false
+  end
+
+  def author_description(user)
+    return if user.description.blank?
+
+    content_tag(:div, user.description, id: "author-description")
+  end
+
+  def author_link(article)
+    h(article.author_name)
+  end
+end