occams 1.0.0

data/app/controllers/occams/admin/cms/sites_controller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class Occams::Admin::Cms::SitesController < Occams::Admin::Cms::BaseController
+
+  skip_before_action  :load_admin_site,
+                      :load_seeds
+
+  before_action :build_site,  only: %i[new create]
+  before_action :load_site,   only: %i[edit update destroy]
+  before_action :authorize
+
+  def index
+    return redirect_to action: :new if ::Occams::Cms::Site.count.zero?
+    @site   = ::Occams::Cms::Site.find_by_id(session[:site_id])
+    @sites  = ::Occams::Cms::Site.all
+  end
+
+  def new
+    render
+  end
+
+  def edit
+    render
+  end
+
+  def create
+    @site.save!
+    flash[:success] = I18n.t("occams.admin.cms.sites.created")
+    redirect_to occams_admin_cms_site_layouts_path(@site)
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.sites.creation_failure")
+    render action: :new
+  end
+
+  def update
+    @site.update!(site_params)
+    flash[:success] = I18n.t("occams.admin.cms.sites.updated")
+    redirect_to action: :edit, id: @site
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.sites.update_failure")
+    render action: :edit
+  end
+
+  def destroy
+    @site.destroy
+    flash[:success] = I18n.t("occams.admin.cms.sites.deleted")
+    redirect_to action: :index
+  end
+
+protected
+
+  def build_site
+    @site = ::Occams::Cms::Site.new(site_params)
+    @site.hostname ||= request.host.downcase
+  end
+
+  def load_site
+    @site = ::Occams::Cms::Site.find(params[:id])
+    I18n.locale = Occams.config.admin_locale || @site.locale
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t("occams.admin.cms.sites.not_found")
+    redirect_to action: :index
+  end
+
+  def site_params
+    params.fetch(:site, {}).permit!
+  end
+
+end

data/app/controllers/occams/admin/cms/snippets_controller.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Occams::Admin::Cms::SnippetsController < Occams::Admin::Cms::BaseController
+
+  include ::Occams::ReorderAction
+  self.reorder_action_resource = ::Occams::Cms::Snippet
+
+  before_action :build_snippet, only: %i[new create]
+  before_action :load_snippet,  only: %i[edit update destroy]
+  before_action :authorize
+
+  def index
+    return redirect_to action: :new if @site.snippets.count.zero?
+    @snippets = @site.snippets.includes(:categories).for_category(params[:categories]).order(:position)
+  end
+
+  def new
+    render
+  end
+
+  def edit
+    @snippet.attributes = snippet_params
+  end
+
+  def create
+    @snippet.save!
+    flash[:success] = I18n.t("occams.admin.cms.snippets.created")
+    redirect_to action: :edit, id: @snippet
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.snippets.creation_failure")
+    render action: :new
+  end
+
+  def update
+    @snippet.update!(snippet_params)
+    flash[:success] = I18n.t("occams.admin.cms.snippets.updated")
+    redirect_to action: :edit, id: @snippet
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.snippets.update_failure")
+    render action: :edit
+  end
+
+  def destroy
+    @snippet.destroy
+    flash[:success] = I18n.t("occams.admin.cms.snippets.deleted")
+    redirect_to action: :index
+  end
+
+protected
+
+  def build_snippet
+    @snippet = @site.snippets.new(snippet_params)
+  end
+
+  def load_snippet
+    @snippet = @site.snippets.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t("occams.admin.cms.snippets.not_found")
+    redirect_to action: :index
+  end
+
+  def snippet_params
+    params.fetch(:snippet, {}).permit!
+  end
+
+end

data/app/controllers/occams/admin/cms/translations_controller.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+class Occams::Admin::Cms::TranslationsController < Occams::Admin::Cms::BaseController
+
+  helper_method :translation_select_options
+
+  before_action :load_page
+  before_action :build_translation,   only: %i[new create]
+  before_action :load_translation,    only: %i[edit update destroy]
+  before_action :authorize
+  before_action :preview_translation, only: %i[create update]
+
+  def new
+    render
+  end
+
+  def edit
+    render
+  end
+
+  def create
+    @translation.save!
+    flash[:success] = I18n.t("occams.admin.cms.translations.created")
+    redirect_to action: :edit, id: @translation
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.translations.creation_failure")
+    render action: :new
+  end
+
+  def update
+    @translation.update!(translation_params)
+    flash[:success] = I18n.t("occams.admin.cms.translations.updated")
+    redirect_to action: :edit, id: @translation
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = I18n.t("occams.admin.cms.translations.update_failure")
+    render action: :edit
+  end
+
+  def destroy
+    @translation.destroy
+    flash[:success] = I18n.t("occams.admin.cms.translations.deleted")
+    redirect_to edit_occams_admin_cms_site_page_path(@site, @page)
+  end
+
+  def form_fragments
+    @translation = @page.translations.find_by(id: params[:id]) || @page.translations.new
+    @translation.layout = @site.layouts.find_by(id: params[:layout_id])
+
+    render(
+      partial:  "occams/admin/cms/fragments/form_fragments",
+      locals:   { record: @translation, scope: :translation },
+      layout:   false
+    )
+  end
+
+private
+
+  def translation_select_options
+    all = Occams.config.locales
+    taken = @page.translations.pluck(:locale) + [@site.locale] - [@translation.locale]
+    all.except(*taken).map { |k, v| ["#{v} (#{k})", k] }
+  end
+
+  def load_page
+    @page = @site.pages.find(params[:page_id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t("occams.admin.cms.pages.not_found")
+    redirect_to occams_admin_cms_site_pages_path(@site)
+  end
+
+  def build_translation
+    @translation = @page.translations.new(translation_params)
+    @translation.layout ||= @page.layout
+  end
+
+  def load_translation
+    @translation = @page.translations.find(params[:id])
+    @translation.attributes = translation_params
+  rescue ActiveRecord::RecordNotFound
+    flash[:danger] = I18n.t("occams.admin.cms.translations.not_found")
+    redirect_to edit_occams_admin_cms_site_page_path(@site, @page)
+  end
+
+  def translation_params
+    params.fetch(:translation, {}).permit!
+  end
+
+  def preview_translation
+    if params[:preview]
+      layout = @translation.layout.app_layout.blank? ? false : @translation.layout.app_layout
+      @cms_site   = @page.site
+      @cms_layout = @translation.layout
+      @cms_page   = @page
+
+      # Make sure to use the site locale to render the preview becaue it might
+      # be different from the admin locale.
+      I18n.locale = @translation.locale
+
+      # Chrome chokes on content with iframes. Issue #434
+      response.headers["X-XSS-Protection"] = "0"
+
+      # raise
+      render inline: @translation.render, layout: layout, content_type: "text/html"
+    end
+  end
+
+end

data/app/controllers/occams/cms/assets_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Occams::Cms::AssetsController < Occams::Cms::BaseController
+
+  skip_before_action :verify_authenticity_token, raise: false
+
+  before_action :load_cms_layout,
+                :use_null_session
+
+  after_action :set_cache_control_header
+
+  def render_css
+    render body: @cms_layout.css, content_type: "text/css"
+  end
+
+  def render_js
+    render body: @cms_layout.js, content_type: "application/javascript"
+  end
+
+protected
+
+  def load_cms_layout
+    @cms_layout = @cms_site.layouts.find_by_identifier!(params[:identifier])
+  rescue ActiveRecord::RecordNotFound
+    render body: nil, status: 404
+  end
+
+  # null_session avoids cookies and flash updates
+  def use_null_session
+    ActionController::RequestForgeryProtection::ProtectionMethods::NullSession.new(self)
+      .handle_unverified_request
+  end
+
+  def set_cache_control_header
+    if params[:cache_buster].present?
+      response.headers["Cache-Control"] = "public, max-age=#{1.year.to_i}"
+    end
+  end
+
+end

data/app/controllers/occams/cms/base_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Occams::Cms::BaseController < Occams.config.public_base_controller.to_s.constantize
+
+  before_action :load_cms_site
+
+  helper Occams::CmsHelper
+
+protected
+
+  def load_cms_site
+    @cms_site ||=
+      if params[:site_id]
+        ::Occams::Cms::Site.find_by_id(params[:site_id])
+      else
+        ::Occams::Cms::Site.find_site(request.host_with_port.downcase, request.fullpath)
+      end
+
+    if @cms_site
+      if @cms_site.path.present? && !params[:site_id]
+        if params[:cms_path]&.match(%r{\A#{@cms_site.path}})
+          params[:cms_path].gsub!(%r{\A#{@cms_site.path}}, "")
+          params[:cms_path]&.gsub!(%r{\A/}, "")
+        else
+          raise ActionController::RoutingError, "Site Not Found"
+        end
+      end
+    else
+      raise ActionController::RoutingError, "Site Not Found"
+    end
+  end
+
+end

data/app/controllers/occams/cms/content_controller.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Occams::Cms::ContentController < Occams::Cms::BaseController
+
+  # Authentication module must have `authenticate` method
+  include Occams.config.public_auth.to_s.constantize
+
+  # Authorization module must have `authorize` method
+  include Occams.config.public_authorization.to_s.constantize
+
+  before_action :load_seeds
+  before_action :load_cms_page,
+                :authenticate,
+                :authorize,
+                only: :show
+
+  def show
+    if @cms_page.target_page.present?
+      redirect_to @cms_page.target_page.url(relative: true)
+    else
+      respond_to do |format|
+        format.html { render_page }
+        format.json do
+          @cms_page.content = render_to_string(
+            inline: @cms_page.content_cache,
+            layout: false
+          )
+          json_page = @cms_page.as_json(Occams.config.page_to_json_options)
+          render json: json_page
+        end
+      end
+    end
+  end
+
+protected
+
+  def render_page(status = :ok)
+    render  inline:       @cms_page.content_cache,
+            layout:       app_layout,
+            status:       status,
+            content_type: mime_type
+  end
+
+  # it's possible to control mimetype of a page by creating a `mime_type` field
+  def mime_type
+    mime_block = @cms_page.fragments.detect { |f| f.identifier == "mime_type" }
+    mime_block&.content&.strip || "text/html"
+  end
+
+  def app_layout
+    return false if request.xhr? || !@cms_layout
+    @cms_layout.app_layout.present? ? @cms_layout.app_layout : false
+  end
+
+  def load_seeds
+    return unless Occams.config.enable_seeds
+    Occams::Seeds::Importer.new(@cms_site.identifier).import!
+  end
+
+  # Attempting to populate @cms_page and @cms_layout instance variables so they
+  # can be used in view helpers/partials
+  def load_cms_page
+    unless find_cms_page_by_full_path("/#{params[:cms_path]}")
+      if find_cms_page_by_full_path("/404")
+        render_page(:not_found)
+      else
+        message = "Page Not Found at: \"#{params[:cms_path]}\""
+        raise ActionController::RoutingError, message
+      end
+    end
+  end
+
+  # Getting page and setting content_cache and fragments data if we need to
+  # serve translation data
+  def find_cms_page_by_full_path(full_path)
+    @cms_page = @cms_site.pages.published.find_by!(full_path: full_path)
+
+    @cms_page.translate!
+    @cms_layout = @cms_page.layout
+
+    @cms_page
+
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+
+end

data/app/helpers/occams/admin/cms_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Occams
+  module Admin
+    module CmsHelper
+
+      # Wrapper around Occams::FormBuilder
+      def occams_form_with(**options, &block)
+        form_options = options.merge(builder: Occams::FormBuilder)
+        form_options[:bootstrap]  = { layout: :horizontal }
+        form_options[:local]      = true
+        bootstrap_form_with(**form_options, &block)
+      end
+
+      def occams_admin_partial(path, params = {})
+        render path, params
+      rescue ActionView::MissingTemplate
+        if Occams.config.reveal_cms_partials
+          content_tag(:div, class: "occams-admin-partial") do
+            path
+          end
+        end
+      end
+
+      # Injects some content somewhere inside cms admin area
+      def cms_hook(name, options = {})
+        Occams::ViewHooks.render(name, self, options)
+      end
+
+      # @param [String] fragment_id
+      # @param [ActiveStorage::Blob] attachment
+      # @param [Boolean] multiple
+      # @return [String] {{ cms:page_file_link #{fragment_id}, ... }}
+      def cms_page_file_link_tag(fragment_id:, attachment:, multiple:)
+        filename  = ", filename: \"#{attachment.filename}\""  if multiple
+        as        = ", as: image"                             if attachment.image?
+        "{{ cms:page_file_link #{fragment_id}#{filename}#{as} }}"
+      end
+
+      # @param [Occams::Cms::File] file
+      # @return [String] {{ cms:file_link #{file.id}, ... }}
+      def cms_file_link_tag(file)
+        as = ", as: image" if file.attachment.image?
+        "{{ cms:file_link #{file.id}#{as} }}"
+      end
+
+    end
+  end
+end

data/app/helpers/occams/cms_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Occams
+  module CmsHelper
+
+    # Raw content of a page fragment. This is how you get content from unrenderable
+    # tags like {{cms:fragment meta, render: false}}
+    # Example:
+    #   cms_fragment_content(:left_column, CmsPage.first)
+    #   cms_fragment_content(:left_column) # if @cms_page is present
+    def cms_fragment_content(identifier, page = @cms_page)
+      frag = page&.fragments&.detect { |f| f.identifier == identifier.to_s }
+      return "" unless frag
+      case frag.tag
+      when "date", "datetime"
+        frag.datetime
+      when "checkbox"
+        frag.boolean
+      when "file", "files"
+        frag.attachments
+      else
+        frag.content
+      end
+    end
+
+    # Same as cms_fragment_content but with cms tags expanded and rendered. Use
+    # it only if you know you got more stuff in the fragment content other than
+    # text because this is a potentially expensive call.
+    def cms_fragment_render(identifier, page = @cms_page)
+      node = page.fragment_nodes.detect { |n| n.identifier == identifier.to_s }
+      return "" unless node
+      node.renderable = true
+      render inline: page.render([node])
+    end
+
+    # Raw content of a snippet.
+    # Example:
+    #   cms_snippet_content(:my_snippet)
+    def cms_snippet_content(identifier, cms_site = @cms_site)
+      cms_site ||= cms_site_detect
+      snippet = cms_site&.snippets&.find_by_identifier(identifier)
+      return "" unless snippet
+      snippet.content
+    end
+
+    # Same as cms_snippet_content but cms tags will be expanded. Note that there
+    # is no page context, so snippet cannot contain fragment tags.
+    def cms_snippet_render(identifier, cms_site = @cms_site)
+      cms_site ||= cms_site_detect
+      snippet = cms_site&.snippets&.find_by_identifier(identifier)
+      return "" unless snippet
+      r = Occams::Content::Renderer.new(snippet)
+      render inline: r.render(r.nodes(r.tokenize(snippet.content)))
+    end
+
+    def cms_site_detect
+      host = request.host_with_port.downcase
+      path = request.fullpath
+      Occams::Cms::Site.find_site(host, path)
+    end
+
+    # Wrapper to deal with Kaminari vs WillPaginate
+    def occams_paginate(collection)
+      return unless collection
+      if defined?(WillPaginate)
+        will_paginate collection
+      elsif defined?(Kaminari)
+        paginate collection, theme: "occams"
+      end
+    end
+
+  end
+end

data/app/models/concerns/occams/cms/with_categories.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Occams::Cms::WithCategories
+
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :categorizations,
+      as:         :categorized,
+      class_name: "Occams::Cms::Categorization",
+      dependent:  :destroy
+    has_many :categories,
+      through:    :categorizations,
+      class_name: "Occams::Cms::Category"
+
+    attr_writer :category_ids
+
+    after_save :sync_categories
+
+    scope :for_category, ->(*categories) {
+      if (categories = [categories].flatten.compact).present?
+        distinct
+          .joins(categorizations: :category)
+          .where("occams_cms_categories.label" => categories)
+      end
+    }
+  end
+
+  def category_ids
+    @category_ids ||= categories.pluck(:id)
+  end
+
+  def sync_categories
+    return unless category_ids.is_a?(Array)
+
+    scope = Occams::Cms::Category.of_type(self.class.to_s)
+    existing_ids = scope.pluck(:id)
+
+    ids_to_add = category_ids.map(&:to_i)
+
+    # adding categorizations
+    ids_to_add.each do |id|
+      if (category = scope.find_by_id(id))
+        category.categorizations.create(categorized: self)
+      end
+    end
+
+    # removing categorizations
+    ids_to_remove = existing_ids - ids_to_add
+    categorizations.where(category_id: ids_to_remove).destroy_all
+  end
+
+end

data/app/models/concerns/occams/cms/with_fragments.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Occams::Cms::WithFragments
+
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :fragments_attributes_changed
+
+    belongs_to :layout,
+      class_name: "Occams::Cms::Layout"
+
+    has_many :fragments,
+      class_name: "Occams::Cms::Fragment",
+      as:         :record,
+      autosave:   true,
+      dependent:  :destroy
+
+    before_save :clear_content_cache
+
+    validates :layout,
+      presence: true
+  end
+
+  # Array of fragment hashes in the following format:
+  #   [
+  #     {identifier: "frag_a", format: "text", content: "fragment a content"},
+  #     {identifier: "frag_b", format: "file", files: [{file_a}, {file_b}]}
+  #   ]
+  # It also handles when frag hashes come in as a hash:
+  #   {
+  #     "0" => {identifer: "foo", content: "bar"},
+  #     "1" => {identifier: "bar", content: "foo"}
+  #   }
+  def fragments_attributes=(frag_hashes = [])
+    frag_hashes = frag_hashes.values if frag_hashes.is_a?(Hash)
+
+    frag_hashes.each do |frag_attrs|
+      unless frag_attrs.is_a?(HashWithIndifferentAccess)
+        frag_attrs.symbolize_keys!
+      end
+
+      identifier = frag_attrs.delete(:identifier)
+
+      fragment =
+        fragments.detect { |f| f.identifier == identifier } ||
+        fragments.build(identifier: identifier)
+
+      fragment.attributes = frag_attrs
+
+      # tracking dirty
+      self.fragments_attributes_changed ||= fragment.changed?
+    end
+  end
+
+  # Snapshop of page fragments data used primarily for saving revisions
+  def fragments_attributes(was = false)
+    fragments.collect do |frag|
+      attrs = {}
+      %i[identifier tag content datetime boolean].each do |column|
+        attrs[column] = frag.send(was ? "#{column}_was" : column)
+      end
+      # TODO: save files against revision (not on db though)
+      # attrs[:files] = frag.attachments.collect do |a|
+      #   {io: a.download, filename: a.filename.to_s, content_type: a.content_type}
+      # end
+      attrs
+    end
+  end
+
+  # Method to collect prevous state of blocks for revisions
+  def fragments_attributes_was
+    fragments_attributes(:previous_values)
+  end
+
+  # Grabbing nodes that we need to render form elements in the admin area
+  # Rejecting duplicates as we'd need to render only one form field. Don't declare
+  # duplicate tags on the layout. That's wierd (but still works).
+  def fragment_nodes
+    nodes
+      .select { |n| n.is_a?(Occams::Content::Tag::Fragment) }
+      .uniq(&:identifier)
+  end
+
+  # Rendered content of the page. We grab whatever layout is associated with the
+  # page and feed its content tokens to the renderer while passing this page as
+  # context.
+  def render(n = nodes)
+    renderer.render(n)
+  end
+
+  # If content_cache column is populated we don't need to call render for this
+  # page.
+  def content_cache
+    if (cache = read_attribute(:content_cache)).nil?
+      cache = render
+      update_column(:content_cache, cache) unless new_record?
+    end
+    cache
+  end
+
+  # Nuking content cache so it can be regenerated.
+  def clear_content_cache!
+    update_column(:content_cache, nil)
+  end
+
+  # Blanking cache on page saves so it can be regenerated on access
+  def clear_content_cache
+    write_attribute(:content_cache, nil)
+  end
+
+protected
+
+  def renderer
+    Occams::Content::Renderer.new(self)
+  end
+
+  def nodes
+    return [] unless layout.present?
+
+    tokens = layout.content_tokens
+    renderer.nodes(tokens)
+  end
+
+end