publify_core 9.0.0.pre1

data/app/controllers/feedback_controller.rb

@@ -0,0 +1,47 @@
+class FeedbackController < BaseController
+  before_action :get_article, only: [:create]
+
+  cache_sweeper :blog_sweeper
+
+  # 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.
+  def index
+    @page_title = self.class.name.to_s.sub(/Controller$/, '')
+    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 text: '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 }
+    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

@@ -0,0 +1,37 @@
+class NotesController < ContentController
+  require 'json'
+
+  layout :theme_layout
+  cache_sweeper :blog_sweeper
+  caches_page :index, :show, if: proc { |c| c.request.query_string == '' }
+
+  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: 200
+    end
+  end
+
+  def show
+    @note = Note.published.find_by permalink: CGI.escape(params[:permalink])
+
+    return render 'errors/404', status: 404 unless @note
+
+    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,62 @@
+class SetupController < BaseController
+  before_action :check_config, only: 'index'
+  layout 'accounts'
+
+  def index
+    return unless request.post?
+
+    this_blog.blog_name = params[:setting][:blog_name]
+    this_blog.base_url = blog_base_url
+
+    @user = User.new(login: 'admin',
+                     email: params[:setting][:email],
+                     nickname: 'Publify Admin')
+    @user.generate_password!
+    @user.name = @user.login
+
+    unless this_blog.valid? && @user.valid?
+      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
+      create_first_post @user
+      create_first_page @user
+    end
+
+    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)
+  end
+
+  def create_first_page(user)
+    this_blog.pages.create(name: 'about',
+                           published: true,
+                           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,55 @@
+class TagsController < ContentController
+  before_action :auto_discovery_feed, only: [:show, :index]
+  layout :theme_layout
+  cache_sweeper :blog_sweeper
+
+  caches_page :index, :show, if: proc { |c|
+    c.request.query_string == ''
+  }
+
+  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}"
+  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
+    respond_to do |format|
+      format.html do
+        if @articles.empty?
+          render 'errors/404', status: 404
+        else
+          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
+      end
+
+      format.rss do
+        @articles = @articles[0, this_blog.limit_rss_display]
+        render 'articles/index_rss_feed', layout: false
+      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,9 @@
+class TextController < BaseController
+  def humans
+    render text: this_blog.humans
+  end
+
+  def robots
+    render text: this_blog.robots
+  end
+end

data/app/controllers/textfilter_controller.rb

@@ -0,0 +1,3 @@
+# TODO: Remove
+class TextfilterController < BaseController
+end

data/app/controllers/theme_controller.rb

@@ -0,0 +1,59 @@
+class ThemeController < ContentController
+  def stylesheets
+    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')
+  end
+
+  def images
+    render_theme_item(:images, params[:filename])
+  end
+
+  def fonts
+    render_theme_item(:fonts, params[:filename])
+  end
+
+  def error
+    render nothing: true, status: 404
+  end
+
+  def static_view_test
+  end
+
+  private
+
+  def render_theme_item(type, file, mime = nil)
+    mime ||= mime_for(file)
+    if file.split(%r{[\\/]}).include?('..')
+      return (render 'errors/404', status: 404)
+    end
+
+    src = this_blog.current_theme.path + "/#{type}/#{file}"
+    return (render text: 'Not Found', status: 404) unless File.exist? src
+
+    cache_page File.read(src) if perform_caching
+
+    send_file(src, type: mime, disposition: 'inline', stream: true)
+  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/trackbacks_controller.rb

@@ -0,0 +1,36 @@
+class TrackbacksController < FeedbackController
+  def create
+    @error_message = catch(:error) do
+      if this_blog.global_pings_disable
+        throw :error, 'Trackback not saved'
+      elsif params[:__mode] == 'rss'
+        # Part of the trackback spec... not sure what we should be doing here though.
+      else
+        begin
+          @trackback = this_blog.ping_article! trackback_params
+        rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid
+          throw :error, "Article id #{params[:id]} not found."
+        rescue ActiveRecord::RecordInvalid
+          throw :error, 'Trackback not saved'
+        end
+      end
+    end
+
+    respond_to do |format|
+      format.xml { render 'trackback', formats: [:xml], handlers: [:builder] }
+      format.html { render nothing: true }
+    end
+  end
+
+  protected
+
+  def trackback_params
+    params.
+      permit(:blog_name, :excerpt, :title, :url, :article_id).
+      merge(ip: request.remote_ip, published: true)
+  end
+
+  def get_article
+    true
+  end
+end

data/app/controllers/xml_controller.rb

@@ -0,0 +1,70 @@
+class XmlController < BaseController
+  caches_page :feed, if: proc { |c|
+    c.request.query_string == ''
+  }
+
+  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(text: 'Unsupported format', status: 404) unless @format
+    end
+
+    # 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
+
+      @feed_title = this_blog.blog_name
+      @link = this_blog.base_url
+      @self_url = url_for(params)
+
+      @items += Article.find_already_published(1000)
+      @items += Page.find_already_published(1000)
+      @items += Tag.find_all_with_article_counters unless this_blog.unindex_tags
+
+      respond_to do |format|
+        format.googlesitemap
+      end
+    else
+      return render(text: 'Unsupported feed type', status: 404)
+    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

data/app/helpers/admin/base_helper.rb

@@ -0,0 +1,87 @@
+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]
+    end
+  end
+
+  def text_filter_options_with_id
+    TextFilter.all.map do |filter|
+      [filter.description, filter.id]
+    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,42 @@
+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,8 @@
+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,39 @@
+module AuthorsHelper
+  include BlogHelper
+
+  def display_profile_item(item, item_desc)
+    return unless item.present?
+    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 unless user.description.present?
+
+    content_tag(:div, user.description, id: 'author-description')
+  end
+
+  def author_link(article)
+    return h(article.author) if just_author?(article.user)
+    return h(article.user.name) if just_name?(article.user)
+    content_tag(:a, href: "mailto:#{h article.user.email}") { h(article.user.name) }
+  end
+
+  private
+
+  def just_author?(author)
+    author.nil? || author.name.blank?
+  end
+
+  def just_name?(author)
+    author.present? && !this_blog.link_to_author
+  end
+end