publify_core 9.0.0.pre5 → 9.2.0

data/app/controllers/comments_controller.rb

@@ -1,5 +1,7 @@
-class CommentsController < FeedbackController
-  before_action :get_article, only: [:create, :preview]
+# 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
@@ -10,12 +12,10 @@ class CommentsController < FeedbackController
       @comment.user_id = current_user.id if current_user.id == session[:user_id]
     end
 
-    set_cookies_for @comment
+    remember_author_info_for @comment
 
-    partial = '/articles/comment_failed'
-    if recaptcha_ok_for?(@comment) && @comment.save
-      partial = '/articles/comment'
-    end
+    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 }
@@ -23,14 +23,14 @@ class CommentsController < FeedbackController
   end
 
   def preview
-    return render plain: 'Comments are closed' if @article.comments_closed?
+    return render plain: "Comments are closed" if @article.comments_closed?
 
     if comment_params[:body].blank?
       head :ok
       return
     end
 
-    @comment = Comment.new(comment_params)
+    @comment = @article.comments.build(comment_params)
   end
 
   protected
@@ -42,23 +42,22 @@ class CommentsController < FeedbackController
 
   def new_comment_defaults
     { ip: request.remote_ip,
-      author: 'Anonymous',
-      published: true,
+      author: "Anonymous",
       user: @current_user,
-      user_agent: request.env['HTTP_USER_AGENT'],
-      referrer: request.env['HTTP_REFERER'],
+      user_agent: request.env["HTTP_USER_AGENT"],
+      referrer: request.env["HTTP_REFERER"],
       permalink: @article.permalink_url }.stringify_keys
   end
 
-  def set_cookies_for(comment)
+  def remember_author_info_for(comment)
     add_to_cookies(:author, comment.author)
     add_to_cookies(:url, comment.url)
-    unless comment.email.blank?
+    if comment.email.present?
       add_to_cookies(:gravatar_id, Digest::MD5.hexdigest(comment.email.strip))
     end
   end
 
-  def get_article
+  def set_article
     @article = Article.find(params[:article_id])
   end
 

data/app/controllers/content_controller.rb

@@ -1,31 +1,24 @@
-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
+# frozen_string_literal: true
 
-  protected
+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)
+      @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

@@ -1,45 +1,13 @@
-class FeedbackController < BaseController
-  before_action :get_article, only: [:create]
+# frozen_string_literal: true
 
-  # Used only by comments. Maybe need move to comments controller
-  # or use it in our code with send some feed about trackback
-  #
-  # Redirect to article with good anchor with /comments?article_id=xxx ou
-  # /trackacks?article_id=xxx
-  #
-  # If no article_id params, so no page found. TODO: See all
-  # comments/trackbacks with paginate ?
-  #
-  # If /comments.rss|atom or /trabacks.atom|rss see a feed about all comments
-  # or trackback
-  #
-  # If article_id params in feed see only this comment|feedback on this
-  # article.
-  #
-  # TODO: It's usefull but use anywhere. Create some extension in xml_sidebar
-  # to define this feed.
+class FeedbackController < BaseController
   def index
-    @page_title = self.class.name.to_s.sub(/Controller$/, '')
+    @feedback = Feedback.ham.
+      newest_first.
+      limit(this_blog.per_page(params[:format]))
     respond_to do |format|
-      format.html do
-        if params[:article_id]
-          article = Article.find(params[:article_id])
-          redirect_to "#{URI.parse(article.permalink_url).path}\##{@page_title.underscore}"
-        else
-          render plain: 'this space left blank'
-        end
-      end
-      feedbacks = Feedback.from(controller_name, params[:article_id]).limit(this_blog.per_page(params[:format]))
-      format.atom { render_feed 'atom', feedbacks }
-      format.rss { render_feed 'rss', feedbacks }
+      format.atom { render "index", format: "atom" }
+      format.rss { render "index", format: "rss" }
     end
   end
-
-  protected
-
-  def render_feed(format, collection)
-    ivar_name = "@#{self.class.to_s.sub(/Controller$/, '').underscore}"
-    instance_variable_set(ivar_name, collection)
-    render "index_#{format}_feed"
-  end
 end

data/app/controllers/notes_controller.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 class NotesController < ContentController
-  require 'json'
+  require "json"
 
   layout :theme_layout
 
@@ -9,15 +11,13 @@ class NotesController < ContentController
     @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: 200
+      @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])
-
-    return render 'errors/404', status: 404 unless @note
+    @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)

data/app/controllers/setup_controller.rb

@@ -1,30 +1,27 @@
+# frozen_string_literal: true
+
 class SetupController < BaseController
-  before_action :check_config, only: 'index'
-  layout 'accounts'
+  before_action :check_config
+  layout "accounts"
 
-  def index
-    return unless request.post?
+  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',
+    @user = User.new(login: "admin",
                      email: params[:setting][:email],
-                     nickname: 'Publify Admin')
-    @user.generate_password!
+                     password: params[:setting][:password],
+                     text_filter_name: this_blog.text_filter,
+                     nickname: "Publify Admin")
     @user.name = @user.login
 
-    unless this_blog.valid? && @user.valid?
+    unless this_blog.save && @user.save
       redirect_to setup_url
       return
     end
 
-    return unless this_blog.save
-
-    session[:tmppass] = @user.password
-
-    return unless @user.save
-
     sign_in @user
 
     if User.count == 1
@@ -32,31 +29,33 @@ class SetupController < BaseController
       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.create(title: I18n.t('setup.article.title'),
-                              author: user.login,
-                              body: I18n.t('setup.article.body'),
-                              allow_comments: 1,
-                              allow_pings: 1,
-                              published: 1,
-                              user: 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',
-                           published: true,
-                           title: I18n.t('setup.page.about'),
+    this_blog.pages.create(name: "about",
+                           state: "published",
+                           title: I18n.t("setup.page.about"),
                            user: user,
-                           body: I18n.t('setup.page.body'))
+                           body: I18n.t("setup.page.body"))
   end
 
   def check_config
     return unless this_blog.configured?
-    redirect_to controller: 'articles', action: 'index'
+
+    redirect_to controller: "articles", action: "index"
   end
 end

data/app/controllers/tags_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class TagsController < ContentController
   before_action :auto_discovery_feed, only: [:show, :index]
   layout :theme_layout
@@ -5,39 +7,37 @@ class TagsController < ContentController
   def index
     @tags = Tag.page(params[:page]).per(100)
     @page_title = controller_name.capitalize
-    @keywords = ''
-    @description = "#{self.class.to_s.sub(/Controller$/, '')} for #{this_blog.blog_name}"
+    @keywords = ""
+    @description = "Tags for #{this_blog.blog_name}"
   end
 
   def show
-    @grouping = Tag.find_by(name: params[:id])
-    if @grouping.nil?
-      @articles = []
-    else
-      @page_title = this_blog.tag_title_template.to_title(@grouping, this_blog, params)
-      @description = @grouping.description.to_s
-      @keywords = ''
-      @keywords << @grouping.keywords unless @grouping.keywords.blank?
-      @keywords << this_blog.meta_keywords unless this_blog.meta_keywords.blank?
-      @articles = @grouping.articles.published.page(params[:page]).per(10)
-    end
+    @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?
-          render 'errors/404', status: 404
+          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 template_name(params[:id])
         end
       end
 
       format.atom do
         @articles = @articles[0, this_blog.limit_rss_display]
-        render 'articles/index_atom_feed', layout: false
+        render_cached_xml "articles/index_atom_feed", @articles
       end
 
       format.rss do
         @articles = @articles[0, this_blog.limit_rss_display]
-        render 'articles/index_rss_feed', layout: false
+        render_cached_xml "articles/index_rss_feed", @articles
       end
     end
   end

data/app/controllers/text_controller.rb

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

data/app/controllers/textfilter_controller.rb

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

data/app/controllers/theme_controller.rb

@@ -1,10 +1,15 @@
+# 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')
+    render_theme_item(:stylesheets, params[:filename], "text/css; charset=utf-8")
   end
 
-  def javascript
-    render_theme_item(:javascript, params[:filename], 'text/javascript; charset=utf-8')
+  def javascripts
+    render_theme_item(:javascripts, params[:filename], "text/javascript; charset=utf-8")
   end
 
   def images
@@ -24,35 +29,35 @@ class ThemeController < ContentController
   private
 
   def render_theme_item(type, file, mime = nil)
-    mime ||= mime_for(file)
-    if file.split(%r{[\\/]}).include?('..')
-      return (render 'errors/404', status: 404, formats: ['html'])
-    end
+    return render_not_found if file.split(%r{[\\/]}).include?("..")
 
     src = this_blog.current_theme.path + "/#{type}/#{file}"
-    return (render plain: 'Not Found', status: 404) unless File.exist? src
+    return render_not_found unless File.exist? src
 
-    cache_page File.read(src) if perform_caching
+    mime ||= mime_for(file)
+    send_file(src, type: mime, disposition: "inline", stream: true)
+  end
 
-    send_file(src, type: mime, disposition: 'inline', stream: true)
+  def render_not_found
+    render plain: "Not Found", status: :not_found
   end
 
   def mime_for(filename)
     case filename.downcase
     when /\.js$/
-      'text/javascript'
+      "text/javascript"
     when /\.css$/
-      'text/css'
+      "text/css"
     when /\.gif$/
-      'image/gif'
+      "image/gif"
     when /(\.jpg|\.jpeg)$/
-      'image/jpeg'
+      "image/jpeg"
     when /\.png$/
-      'image/png'
+      "image/png"
     when /\.swf$/
-      'application/x-shockwave-flash'
+      "application/x-shockwave-flash"
     else
-      'application/binary'
+      "application/binary"
     end
   end
 end

data/app/controllers/xml_controller.rb

@@ -1,66 +1,20 @@
-class XmlController < BaseController
-  NORMALIZED_FORMAT_FOR = { 'atom' => 'atom', 'rss' => 'rss',
-                            'atom10' => 'atom', 'atom03' => 'atom', 'rss20' => 'rss',
-                            'googlesitemap' => 'googlesitemap', 'rsd' => 'rsd' }.freeze
-
-  ACCEPTED_TYPE = %w(feed comments article tag author trackbacks sitemap).freeze
-
-  def feed
-    @format = 'rss'
-    if params[:format]
-      @format = NORMALIZED_FORMAT_FOR[params[:format]]
-      return render(plain: 'Unsupported format', status: 404) unless @format
-    end
+# frozen_string_literal: true
 
-    # TODO: Move redirects into config/routes.rb, if possible
-    param_type = ACCEPTED_TYPE.dup.delete(params[:type])
-    param_id = params[:id] # .present? && params[:id].to_i # Think about a way to secure that to a valid tag/author for int value ...
-
-    case param_type
-    when 'feed'
-      redirect_to controller: 'articles', action: 'index', format: @format, status: :moved_permanently
-    when 'comments'
-      redirect_to admin_comments_url(format: @format), status: :moved_permanently
-    when 'article'
-      redirect_to this_blog.articles.find(param_id).feed_url(@format), status: :moved_permanently
-    when 'tag', 'author'
-      redirect_to send("#{param_type}_url", param_id, format: @format), status: :moved_permanently
-    when 'trackbacks'
-      redirect_to trackbacks_url(format: @format), status: :moved_permanently
-    when 'sitemap'
-      @items = []
-      @blog = this_blog
+class XmlController < BaseController
+  def sitemap
+    @items = []
+    @blog = this_blog
 
-      @feed_title = this_blog.blog_name
-      @link = this_blog.base_url
-      @self_url = request.url
+    @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_article_counters unless this_blog.unindex_tags
+    @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
-    else
-      return render(plain: 'Unsupported feed type', status: 404)
+    respond_to do |format|
+      format.googlesitemap
     end
   end
-
-  # TODO: Move redirects into config/routes.rb, if possible
-  def articlerss
-    redirect_to(URI.parse(Article.find(params[:id]).feed_url('rss')).path, status: :moved_permanently)
-  end
-
-  def commentrss
-    redirect_to admin_comments_url(format: 'rss'), status: :moved_permanently
-  end
-
-  def trackbackrss
-    redirect_to trackbacks_url(format: 'rss'), status: :moved_permanently
-  end
-
-  def rsd
-    render 'rsd', formats: [:rsd], handlers: [:builder]
-  end
 end