pages_core 3.4.2

data/app/controllers/pages_core/frontend/pages_controller.rb

@@ -0,0 +1,308 @@
+# encoding: utf-8
+
+module PagesCore
+  module Frontend
+    class PagesController < ::FrontendController
+      include PagesCore::FrontendHelper
+      include PagesCore::Templates::ControllerActions
+      include PagesCore::HeadTagsHelper
+
+      caches_page :index if PagesCore.config(:page_cache)
+
+      before_action :disable_xss_protection, only: [:preview]
+      before_action :load_root_pages
+      before_action :find_page, only: [:show, :preview, :add_comment]
+      before_action :canonicalize_url, only: [:show]
+      after_action :cache_page_request, only: [:show]
+
+      def index
+        respond_to do |format|
+          format.html do
+            if self.respond_to?(:no_page_given)
+              no_page_given
+            elsif root_pages.any?
+              @page = root_pages.first
+              render_page
+            else
+              render_error 404
+            end
+          end
+          format.rss do
+            render_rss(all_feed_items)
+          end
+        end
+      end
+
+      def show
+        respond_to do |format|
+          format.html do
+            if @page && @page.published?
+              render_page
+            else
+              render_error 404
+            end
+          end
+          format.rss do
+            render_rss(
+              @page.pages.limit(20),
+              title: "#{PagesCore.config(:side_name)}: #{@page.name}"
+            )
+          end
+          format.json do
+            render json: @page
+          end
+        end
+      end
+
+      # Add a comment to a page. Recaptcha is performed if
+      # PagesCore.config(:recaptcha) is set.
+      def add_comment
+        @comment = new_comment(@page)
+
+        unless captcha_verified?
+          @comment.invalid_captcha = true
+          render_page
+          return
+        end
+
+        if @page.comments_allowed? && !honeypot_triggered?
+          @comment.save
+          if PagesCore.config(:comment_notifications)
+            deliver_comment_notifications(@page, @comment)
+          end
+        end
+
+        redirect_to(page_url(@locale, @page))
+      end
+
+      # Search pages
+      def search
+        @search_query = params[:q] || params[:query] || ""
+        @search_category_id = params[:category_id]
+
+        @pages = Page.search(
+          normalize_search_query(@search_query),
+          search_options(category_id: @search_category_id)
+        )
+        @pages.each { |p| p.localize!(locale) }
+        @pages
+      end
+
+      def preview
+        redirect_to(page_url(@locale, @page)) && return unless logged_in?
+
+        @page.attributes = page_params.merge(
+          status: 2,
+          published_at: Time.now,
+          locale: @locale,
+          redirect_to: nil
+        )
+
+        render_page
+      end
+
+      private
+
+      def all_feed_items
+        Page
+          .where(
+            parent_page_id: Page.enabled_feeds(locale, include_hidden: true)
+          )
+          .order("published_at DESC")
+          .published
+          .limit(20)
+          .localized(locale)
+      end
+
+      def canonical_path(page)
+        if page.redirects?
+          page.redirect_path(locale: page.locale)
+        else
+          page_path(page.locale, page)
+        end
+      end
+
+      def canonicalize_url
+        unless @page.redirects?
+          if request.path != canonical_path(@page)
+            redirect_to canonical_path(@page)
+          end
+        end
+      end
+
+      def disable_xss_protection
+        # Disabling this is probably not a good idea,
+        # but the header causes Chrome to choke when being
+        # redirected back after a submit and the page contains an iframe.
+        response.headers['X-XSS-Protection'] = "0"
+      end
+
+      def preview?
+        @page.new_record?
+      end
+
+      def render(*args)
+        @already_rendered = true
+        super
+      end
+
+      def redirect_to(*args)
+        @already_rendered = true
+        super
+      end
+
+      def rendered?
+        @already_rendered ? true : false
+      end
+
+      def page_template(page)
+        if PagesCore::Templates.names.include?(page.template)
+          page.template
+        else
+          "index"
+        end
+      end
+
+      def render_page
+        if @page.redirects?
+          redirect_to(@page.redirect_path(locale: @locale))
+          return
+        end
+
+        unless document_title?
+          if @page.meta_title?
+            document_title(@page.meta_title)
+          else
+            document_title(@page.name)
+          end
+        end
+
+        # Call template method
+        template = page_template(@page)
+
+        run_template_actions_for(template, @page)
+
+        @page_template_layout = false if @disable_layout
+
+        return if rendered?
+
+        if instance_variables.include?("@page_template_layout")
+          render(
+            template: "pages/templates/#{template}",
+            layout: @page_template_layout
+          )
+        else
+          render template: "pages/templates/#{template}"
+        end
+      end
+
+      # Cache pages by hand. This is dirty, but it works.
+      def cache_page_request
+        status_code = response.status.try(&:to_i)
+        unless status_code == 200 &&
+            PagesCore.config(:page_cache) &&
+            @page && @locale
+          return
+        end
+
+        self.class.cache_page response.body, request.path
+      end
+
+      def permitted_page_attributes
+        [
+          :template, :user_id, :status, :content_order,
+          :feed_enabled, :published_at, :redirect_to, :comments_allowed,
+          :image_link, :news_page, :unique_name, :pinned,
+          :parent_page_id
+        ]
+      end
+
+      def page_params
+        params.require(:page).permit(
+          Page.localized_attributes + permitted_page_attributes
+        )
+      end
+
+      def captcha_verified?
+        !PagesCore.config(:recaptcha) || verify_recaptcha
+      end
+
+      def honeypot_triggered?
+        PagesCore.config(:comment_honeypot) && !params[:email].to_s.empty?
+      end
+
+      def remote_ip
+        request.env["REMOTE_ADDR"]
+      end
+
+      def new_comment(page)
+        PageComment.new(
+          page_comment_params.merge(remote_ip: remote_ip, page_id: page.id)
+        )
+      end
+
+      def comment_recipients(page)
+        PagesCore.config(:comment_notifications)
+          .map { |r| r == :author ? page.author.name_and_email : r }
+          .uniq
+      end
+
+      def deliver_comment_notifications(page, comment)
+        comment_recipients(page).each do |r|
+          AdminMailer.comment_notification(
+            r,
+            page,
+            comment,
+            page_url(locale, page)
+          ).deliver_now
+        end
+      end
+
+      def find_page
+        @page ||= find_page_by_id(params[:id]) || unique_page(params[:id])
+        @page.locale = @locale || I18n.default_locale.to_s
+      end
+
+      def find_page_by_id(id)
+        Page.find(id)
+      rescue
+        nil
+      end
+
+      def page_comment_params
+        params.require(:page_comment).permit(:name, :email, :url, :body)
+      end
+
+      def normalize_search_query(str)
+        str
+          .split(/\s+/)
+          .map { |p| "#{p}*" }
+          .join(" ")
+      end
+
+      def render_rss(items, title: nil)
+        @items, @title = items, title
+        response.headers["Content-Type"] = "application/rss+xml;charset=utf-8"
+        render template: "feeds/pages", layout: false
+      end
+
+      def search_options(category_id: nil)
+        options = {
+          page:      (params[:page] || 1).to_i,
+          per_page:  20,
+          include:   [:localizations, :categories, :image, :author],
+          order:     :published_at,
+          sort_mode: :desc,
+          with: {
+            status:      2,
+            autopublish: 0
+          }
+        }
+        unless category_id.blank?
+          options[:with][:category_ids] = category_id
+        end
+        options
+      end
+    end
+  end
+end

data/app/controllers/pages_core/frontend_controller.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+# Abstract controller for all frontend controllers.
+module PagesCore
+  class FrontendController < ApplicationController
+    include ApplicationHelper
+
+    before_action :set_i18n_locale
+
+    # Loads @root_pages and @rss_feeds. To automatically load these in your
+    # own controllers, add the following line to your controller definition:
+    #
+    #   before_action :load_root_pages
+    #
+    def load_root_pages
+      @root_pages = Page.roots.localized(@locale).published
+      @rss_feeds = Page.where(feed_enabled: true).localized(@locale).published
+    end
+
+    private
+
+    def set_i18n_locale
+      legacy_locales = {
+        "nor" => "nb",
+        "eng" => "en"
+      }
+      locale_param = params[:locale] || I18n.default_locale
+      if legacy_locales[locale_param]
+        locale_param = legacy_locales[locale_param]
+      end
+      I18n.locale = locale_param
+    end
+  end
+end

data/app/controllers/pages_core/images_controller.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module PagesCore
+  class ImagesController < ApplicationController
+    include DynamicImage::Controller
+
+    caches_page :show, :uncropped, :original
+
+    private
+
+    def model
+      Image
+    end
+  end
+end

data/app/controllers/pages_core/sitemaps_controller.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module PagesCore
+  class SitemapsController < ApplicationController
+    caches_page :show
+
+    def show
+      @entries = formatted_entries
+    end
+
+    private
+
+    def format_time(timestamp)
+      if timestamp.kind_of?(Date)
+        timestamp.strftime("%Y-%m-%d")
+      else
+        timestamp.strftime("%Y-%m-%dT%H:%M:%S#{timestamp.formatted_offset}")
+      end
+    end
+
+    def format_record(record)
+      {
+        loc: record_url(record),
+        lastmod: format_time(record.updated_at)
+      }
+    end
+
+    def formatted_entries
+      records.map { |r| format_record(r) }
+    end
+
+    def locales
+      if PagesCore.config.locales
+        PagesCore.config.locales.keys
+      else
+        [I18n.default_locale]
+      end
+    end
+
+    def localized?(record)
+      record.is_a?(PagesCore::Localizable::InstanceMethods)
+    end
+
+    def pages
+      ([Page.root.localize(I18n.default_locale)] +
+        locales.flat_map do |locale|
+        Page.published.localized(locale)
+      end).uniq
+    end
+
+    def page_record_url(record)
+      if record == Page.root && record.locale == I18n.default_locale
+        root_url
+      else
+        page_url(record.locale, record)
+      end
+    end
+
+    def record_url(record)
+      if record.is_a?(Page)
+        page_record_url(record)
+      elsif localized?(record)
+        polymorphic_url(record, locale: record.locale)
+      else
+        polymorphic_url(record)
+      end
+    end
+
+    def records
+      pages
+    end
+  end
+end

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+class SessionsController < ApplicationController
+  def create
+    user = find_user(params[:username], params[:password])
+    authenticate!(user) if user
+
+    if logged_in?
+      redirect_to success_url
+    else
+      flash[:notice] = "The provided email address and password combination " \
+        "was not valid"
+      redirect_to login_url
+    end
+  end
+
+  def destroy
+    flash[:notice] = "You have been logged out"
+    deauthenticate!
+    redirect_to login_url
+  end
+
+  protected
+
+  def find_user(username, password)
+    User.authenticate(username, password: password) if username && password
+  end
+
+  def success_url
+    # TODO: Validate URL
+    params[:success_url] || admin_default_url
+  end
+
+  def login_url
+    # TODO: Validate URL
+    params[:login_url] || login_admin_users_url
+  end
+end

data/app/formatters/pages_core/html_formatter.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module PagesCore
+  class HtmlFormatter
+    include ActionView::Helpers::AssetTagHelper
+    include PagesCore::ImagesHelper
+    include Rails.application.routes.url_helpers
+
+    class << self
+      def to_html(string, options = {})
+        new(string, options).to_html
+      end
+    end
+
+    def initialize(string, options = {})
+      @string = string
+      @options = options
+    end
+
+    def to_html
+      string = parse_images(@string)
+      if @options[:shorten] && string.length > @options[:shorten]
+        string = string[0..@options[:shorten]] + "..."
+      end
+      string += " #{@options[:append]}" if @options[:append]
+      RedCloth.new(string).to_html.html_safe
+    end
+
+    private
+
+    def image_expression
+      /\[image:(\d+)([\s="\-\w]*)?\]/
+    end
+
+    def embed_image(id, size:, class_name:)
+      image = Image.find(id).localize(I18n.locale)
+      class_name = ["image", image_class_name(image), class_name].compact
+      content_tag(
+        :figure,
+        dynamic_image_tag(
+          image,
+          size: size,
+          crop: false,
+          upscale: false
+        ) + image_caption(image),
+        class: class_name
+      )
+    rescue ActiveRecord::RecordNotFound
+      nil
+    end
+
+    def parse_images(string)
+      string.gsub(image_expression).each do |str|
+        id = str.match(image_expression)[1]
+        options = str.match(image_expression)[2]
+
+        size  =  if options.match(/size="(\d*x\d*)"/)
+                   Regexp.last_match(1)
+                 else
+                   "2000x2000"
+                 end
+
+        class_name = if options.match(/class="([\s\-\w]+)"/)
+                       Regexp.last_match(1)
+                     end
+
+        embed_image(id, size: size, class_name: class_name)
+      end
+    end
+
+    def image_caption(image)
+      return unless image.caption?
+      content_tag(:figcaption, image.caption)
+    end
+
+    def image_class_name(image)
+      if image.size.x == image.size.y
+        "square"
+      elsif image.size.x > image.size.y
+        "landscape"
+      else
+        "portrait"
+      end
+    end
+  end
+end

data/app/helpers/admin/admin_helper.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module Admin
+  module AdminHelper
+    include PagesCore::Admin::AdminHelper
+  end
+end

data/app/helpers/admin/menu_helper.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Admin
+  module MenuHelper
+    def header_tabs(group)
+      content_tag :ul, class: group.to_s do
+        menu_items_for(group).map do |item|
+          content_tag :li do
+            path = instance_eval(&item.path)
+            link_to(
+              item.label,
+              path,
+              class: (current_menu_item?(item) ? "current" : "")
+            )
+          end
+        end.join.html_safe
+      end
+    end
+
+    protected
+
+    def menu_item_candidates
+      routes = Rails.application.routes
+      menu_items
+        .map { |item| [item, routes.recognize_path(instance_eval(&item.path))] }
+        .select { |_item, routing| routing[:controller] == params[:controller] }
+    end
+
+    def find_menu_candidate
+      menu_item_candidates
+        .select { |item, routing| yield(item, routing) }
+        .try(&:first)
+        .try(&:first)
+    end
+
+    def menu_candidate_by_current_proc
+      find_menu_candidate do |item, _|
+        item.options[:current] && instance_eval(&item.options[:current])
+      end
+    end
+
+    def current_menu_item
+      menu_candidate_by_current_proc ||
+        find_menu_candidate { |_, r| r[:action] == params[:action] } ||
+        find_menu_candidate { |_, r| r[:action] == "index" } ||
+        find_menu_candidate { |_, _| true }
+    end
+
+    def current_menu_item?(item)
+      item == current_menu_item
+    end
+
+    def menu_items
+      PagesCore::AdminMenuItem.items
+    end
+
+    def menu_items_for(group)
+      menu_items
+        .select { |item| item.group == group }
+        .reject do |item|
+          item.options[:if] && !instance_eval(&item.options[:if])
+        end
+    end
+  end
+end

data/app/helpers/admin/pages_helper.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module Admin
+  module PagesHelper
+    def page_block_field(form, block_name, block_options)
+      if block_options[:size] == :field
+        labelled_field(
+          form.text_field(
+            block_name,
+            class:       ['text', block_options[:class]].join(" "),
+            placeholder: block_options[:placeholder]
+          ),
+          block_options[:title],
+          errors:      form.object.errors[block_name],
+          description: block_options[:description]
+        )
+      else
+        labelled_field form.text_area(
+          block_name,
+          rows:        (block_options[:size] == :large ? 15 : 5),
+          class:       ['rich', block_options[:class]].join(" "),
+          placeholder: block_options[:placeholder]
+        ),
+          block_options[:title],
+          errors:      form.object.errors[block_name],
+          description: block_options[:description]
+      end
+    end
+
+    def available_templates_for_select
+      PagesCore::Templates.names.collect do |template|
+        if template == "index"
+          ["[Default]", "index"]
+        else
+          [template.humanize, template]
+        end
+      end
+    end
+
+    def page_name(page, options = {})
+      page_names = if options[:include_parents]
+                     [page.ancestors, page].flatten
+                   else
+                     [page]
+                   end
+      safe_join(
+        page_names.map { |p| page_name_with_fallback(p) },
+        " » ".html_safe
+      )
+    end
+
+    def publish_time(time)
+      if time.year != Time.now.year
+        time.strftime("on %b %d %Y at %H:%M")
+      elsif time.to_date != Time.now.to_date
+        time.strftime("on %b %Y at %H:%M")
+      else
+        time.strftime("at %H:%M")
+      end
+    end
+
+    private
+
+    def page_name_with_fallback(page)
+      if page.name?
+        page.name.to_s
+      elsif page.localize(I18n.default_locale.to_s).name?
+        "(#{page.localize(I18n.default_locale.to_s).name})"
+      else
+        "(Untitled)"
+      end
+    end
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module ApplicationHelper #:nodoc:
+  include PagesCore::ApplicationHelper
+end