kcy1 1.0

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::ContentController < Comfy::Cms::BaseController
+
+  # Authentication module must have `authenticate` method
+  include ComfortableMexicanSofa.config.public_auth.to_s.constantize
+
+  # Authorization module must have `authorize` method
+  include ComfortableMexicanSofa.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(ComfortableMexicanSofa.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 ComfortableMexicanSofa.config.enable_seeds
+    ComfortableMexicanSofa::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/controllers/concerns/comfy/paginate.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Comfy::Paginate
+
+  # Wrapper to deal with WillPaginate vs Kaminari nonsense
+  def comfy_paginate(scope, per_page: 50)
+    if defined?(WillPaginate)
+      scope.paginate(page: params[:page], per_page: per_page)
+    elsif defined?(Kaminari)
+      scope.page(params[:page]).per(per_page)
+    else
+      scope
+    end
+  end
+
+end

data/app/controllers/concerns/comfy/reorder_action.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Comfy::ReorderAction
+
+  extend ActiveSupport::Concern
+
+  included do
+    mattr_accessor :reorder_action_resource
+  end
+
+  def reorder
+    resource_class = self.class.reorder_action_resource
+    (params.permit(order: [])[:order] || []).each_with_index do |id, index|
+      resource_class.where(id: id).update_all(position: index)
+    end
+    head :ok
+  end
+
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Comfy
+  module Admin
+    module CmsHelper
+
+      # Wrapper around ComfortableMexicanSofa::FormBuilder
+      def comfy_form_with(**options, &block)
+        form_options = options.merge(builder: ComfortableMexicanSofa::FormBuilder)
+        form_options[:bootstrap]  = { layout: :horizontal }
+        form_options[:local]      = true
+        bootstrap_form_with(**form_options, &block)
+      end
+
+      def comfy_admin_partial(path, params = {})
+        render path, params
+      rescue ActionView::MissingTemplate
+        if ComfortableMexicanSofa.config.reveal_cms_partials
+          content_tag(:div, class: "comfy-admin-partial") do
+            path
+          end
+        end
+      end
+
+      # Injects some content somewhere inside cms admin area
+      def cms_hook(name, options = {})
+        ComfortableMexicanSofa::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 [Comfy::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/comfy/cms_helper.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Comfy
+  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 = ComfortableMexicanSofa::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
+      Comfy::Cms::Site.find_site(host, path)
+    end
+
+    # Wrapper to deal with Kaminari vs WillPaginate
+    def comfy_paginate(collection)
+      return unless collection
+      if defined?(WillPaginate)
+        will_paginate collection
+      elsif defined?(Kaminari)
+        paginate collection, theme: "comfy"
+      end
+    end
+
+  end
+end

data/app/models/comfy/cms/categorization.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Categorization < ActiveRecord::Base
+
+  self.table_name = "comfy_cms_categorizations"
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :category
+  belongs_to :categorized,
+    polymorphic: true
+
+  # -- Validations -------------------------------------------------------------
+  validates :category_id,
+    uniqueness: { scope: %i[categorized_type categorized_id] }
+
+end

data/app/models/comfy/cms/category.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Category < ActiveRecord::Base
+
+  self.table_name = "comfy_cms_categories"
+
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :categorizations,
+    dependent: :destroy
+
+  # -- Validations ----------------------------------------------------------
+  validates :label,
+    presence:   true,
+    uniqueness: { scope: %i[categorized_type site_id] }
+  validates :categorized_type,
+    presence:   true
+
+  # -- Scopes ---------------------------------------------------------------
+  scope :of_type, ->(type) {
+    where(categorized_type: type)
+  }
+
+end

data/app/models/comfy/cms/file.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::File < ActiveRecord::Base
+
+  self.table_name = "comfy_cms_files"
+
+  include Comfy::Cms::WithCategories
+
+  VARIANT_SIZE = {
+    redactor: { resize: "100x75^",   gravity: "center", crop: "100x75+0+0" },
+    thumb:    { resize: "200x150^",  gravity: "center", crop: "200x150+0+0" },
+    icon:     { resize: "28x28^",    gravity: "center", crop: "28x28+0+0" }
+  }.freeze
+
+  # temporary place to store attachment
+  attr_accessor :file
+
+  has_one_attached :attachment
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :site
+
+  # -- Callbacks ---------------------------------------------------------------
+  before_validation :assign_label, on: :create
+  before_create :assign_position
+  after_save :process_attachment
+
+  # -- Validations -------------------------------------------------------------
+  validates :label, presence: true
+  validates :file, presence: true, on: :create
+
+  # -- Scopes ------------------------------------------------------------------
+  # When we need to grab only files with image attachments.
+  # Don't forget to include `with_attached_attachment` before calling this
+  scope :with_images, -> {
+    where("active_storage_blobs.content_type LIKE 'image/%'").references(:blob)
+  }
+
+protected
+
+  def assign_position
+    max = Comfy::Cms::File.maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+
+  # TODO: Change db schema not to set blank string
+  def assign_label
+    return if label.present?
+    self.label = file&.original_filename
+  end
+
+  def process_attachment
+    return if @file.blank?
+    attachment.attach(@file)
+  end
+
+end

data/app/models/comfy/cms/fragment.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Fragment < ActiveRecord::Base
+
+  self.table_name = "comfy_cms_fragments"
+
+  has_many_attached :attachments
+
+  serialize :content
+
+  attr_reader :files
+
+  # -- Callbacks ---------------------------------------------------------------
+  after_save  :remove_attachments,
+              :add_attachments
+
+  # -- Relationships -----------------------------------------------------------
+  belongs_to :record, polymorphic: true, touch: true
+
+  # -- Validations -------------------------------------------------------------
+  validates :identifier,
+    presence:   true,
+    uniqueness: { scope: :record }
+
+  # -- Instance Methods --------------------------------------------------------
+
+  # Temporary accessor for uploaded files. We can only attach to persisted
+  # records so we are deffering it to the after_save callback.
+  # Note: hijacking dirty tracking to force trigger callbacks later.
+  def files=(files)
+    @files = [files].flatten.compact
+    content_will_change! if @files.present?
+  end
+
+  def file_ids_destroy=(ids)
+    @file_ids_destroy = [ids].flatten.compact
+    content_will_change! if @file_ids_destroy.present?
+  end
+
+protected
+
+  def remove_attachments
+    return unless @file_ids_destroy.present?
+    attachments.where(id: @file_ids_destroy).destroy_all
+  end
+
+  def add_attachments
+    return if @files.blank?
+
+    # If we're dealing with a single file
+    if tag == "file"
+      @files = [@files.first]
+      attachments&.purge_later
+    end
+
+    attachments.attach(@files)
+  end
+
+end

data/app/models/comfy/cms/layout.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Comfy::Cms::Layout < ActiveRecord::Base
+
+  self.table_name = "comfy_cms_layouts"
+
+  cms_acts_as_tree
+  cms_has_revisions_for :content, :css, :js
+
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :pages, dependent: :nullify
+
+  # -- Callbacks ---------------------------------------------------------------
+  before_validation :assign_label
+  before_create :assign_position
+  after_save    :clear_page_content_cache
+  after_destroy :clear_page_content_cache
+
+  # -- Validations -------------------------------------------------------------
+  validates :site_id,
+    presence:   true
+  validates :label,
+    presence:   true
+  validates :identifier,
+    presence:   true,
+    uniqueness: { scope: :site_id },
+    format:     { with: %r{\A\w[a-z0-9_-]*\z}i }
+
+  # -- Class Methods -----------------------------------------------------------
+  # Tree-like structure for layouts
+  def self.options_for_select(site, current_layout = nil)
+    options = []
+
+    options_for_layout = ->(layout, depth = 0) do
+      return if layout == current_layout
+
+      options << ["#{'. . ' * depth}#{layout.label}", layout.id]
+
+      layout.children.order(:position).each do |child_layout|
+        options_for_layout.call(child_layout, depth + 1)
+      end
+    end
+
+    site.layouts.roots.order(:position).each do |layout|
+      options_for_layout.call(layout)
+    end
+
+    options
+  end
+
+  # List of available application layouts
+  def self.app_layouts_for_select(view_paths)
+    view_paths.map(&:to_s).select { |path| path.start_with?(Rails.root.to_s) }.flat_map do |full_path|
+      Dir.glob("#{full_path}/layouts/**/*.html.*").collect do |filename|
+        filename.gsub!("#{full_path}/layouts/", "")
+        filename.split("/").last[0...1] == "_" ? nil : filename.split(".").first
+      end.compact.sort
+    end.compact.uniq.sort
+  end
+
+  # -- Instance Methods --------------------------------------------------------
+  # Tokenized layout content that also pulls in parent layout (if there's one)
+  # and merges on the {{cms:tag_type content}} tag (if parent layout has that).
+  # Returns a list of tokens that can be fed into the renderer.
+  def content_tokens
+    renderer  = ComfortableMexicanSofa::Content::Renderer.new(nil)
+    tokens    = renderer.tokenize(content)
+
+    if parent
+      fragment_tags = ComfortableMexicanSofa::Content::Tag::Fragment.subclasses.map do |c|
+        ComfortableMexicanSofa::Content::Renderer.tags.key(c)
+      end
+
+      parent_tokens = parent.content_tokens
+      replacement_position = parent_tokens.index do |n|
+        n.is_a?(Hash) &&
+        fragment_tags.member?(n[:tag_class]) &&
+        n[:tag_params].split(%r{\s}).first == "content"
+      end
+
+      if replacement_position
+        parent_tokens[replacement_position] = tokens
+        tokens = parent_tokens.flatten
+      end
+    end
+
+    tokens
+  end
+
+  def cache_buster
+    updated_at.to_i
+  end
+
+  # Forcing page content reload
+  def clear_page_content_cache
+    Comfy::Cms::Page.where(id: pages.pluck(:id)).update_all(content_cache: nil)
+    children.each(&:clear_page_content_cache)
+  end
+
+protected
+
+  def assign_label
+    self.label = label.blank? ? identifier.try(:titleize) : label
+  end
+
+  def assign_position
+    return if position.to_i.positive?
+    max = site.layouts.where(parent_id: parent_id).maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+
+end