ComfortableMexicanSofa 2.0.18

data/lib/comfortable_mexican_sofa/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ComfortableMexicanSofa
+
+  class Error < StandardError
+  end
+
+  class MissingSite < ComfortableMexicanSofa::Error
+
+    def initialize(identifier)
+      super "Cannot find CMS Site with identifier: #{identifier}"
+    end
+
+  end
+
+  class MissingLayout < ComfortableMexicanSofa::Error
+
+    def initialize(identifier)
+      super "Cannot find CMS Layout with identifier: #{identifier}"
+    end
+
+  end
+
+  class MissingPage < ComfortableMexicanSofa::Error
+
+    def initialize(path)
+      super "Cannot find CMS Page at #{path}"
+    end
+
+  end
+
+end

data/lib/comfortable_mexican_sofa/extensions/acts_as_tree.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module ComfortableMexicanSofa::ActsAsTree
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def cms_acts_as_tree(options = {})
+      configuration = {
+        foreign_key:    "parent_id",
+        order:          nil,
+        counter_cache:  nil,
+        dependent:      :destroy,
+        touch:          false
+      }
+      configuration.update(options) if options.is_a?(Hash)
+
+      belongs_to :parent,
+        optional:       true,
+        class_name:     name,
+        foreign_key:    configuration[:foreign_key],
+        counter_cache:  configuration[:counter_cache],
+        touch:          configuration[:touch]
+
+      has_many :children,
+        -> { order(configuration[:order]) },
+        class_name:   name,
+        foreign_key:  configuration[:foreign_key],
+        dependent:    configuration[:dependent]
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include ComfortableMexicanSofa::ActsAsTree::InstanceMethods
+
+        scope :roots, -> {
+          where("#{configuration[:foreign_key]} IS NULL").
+          order(#{configuration[:order].nil? ? 'nil' : %("#{configuration[:order]}")})
+        }
+
+        def self.root
+          roots.first
+        end
+
+        validates_each "#{configuration[:foreign_key]}" do |record, attr, value|
+          if value
+            if record.id == value
+              record.errors.add attr, "cannot be it's own id"
+            elsif record.descendants.map {|c| c.id}.include?(value)
+              record.errors.add attr, "cannot be a descendant's id"
+            end
+          end
+        end
+      RUBY
+    end
+
+  end
+
+  module InstanceMethods
+
+    # Returns list of ancestors, starting from parent until root.
+    #
+    #   subchild1.ancestors # => [child1, root]
+    def ancestors
+      node  = self
+      nodes = []
+      nodes << node = node.parent while node.parent
+      nodes
+    end
+
+    # Returns all children and children of children
+    def descendants
+      nodes = []
+      children.each do |c|
+        nodes << c
+        nodes << c.descendants
+      end
+      nodes.flatten
+    end
+
+    # Returns the root node of the tree.
+    def root
+      node = self
+      node = node.parent while node.parent
+      node
+    end
+
+    # Checks if this node is a root
+    def root?
+      !parent_id
+    end
+
+    # Returns all siblings of the current node.
+    #
+    #   subchild1.siblings # => [subchild2]
+    def siblings
+      self_and_siblings - [self]
+    end
+
+    # Returns all siblings and a reference to the current node.
+    #
+    #   subchild1.self_and_siblings # => [subchild1, subchild2]
+    def self_and_siblings
+      parent ? parent.children : self.class.roots
+    end
+
+    # BUG: https://github.com/rails/rails/issues/14369
+    # It's still a bug. Remove it to see failing test
+    def parent_id=(id)
+      self.parent = self.class.find_by(id: id)
+    end
+
+  end
+
+end
+
+ActiveSupport.on_load :active_record do
+  include ComfortableMexicanSofa::ActsAsTree
+end

data/lib/comfortable_mexican_sofa/extensions/has_revisions.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ComfortableMexicanSofa::HasRevisions
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+
+    def cms_has_revisions_for(*fields)
+      include ComfortableMexicanSofa::HasRevisions::InstanceMethods
+
+      attr_accessor :revision_data
+
+      has_many :revisions,
+        as:         :record,
+        dependent:  :destroy,
+        class_name: "Comfy::Cms::Revision"
+
+      before_save :prepare_revision
+      after_save  :create_revision
+
+      define_method(:revision_fields) do
+        fields.collect(&:to_s)
+      end
+    end
+
+  end
+
+  module InstanceMethods
+
+    # Preparing revision data. A bit of a special thing to grab page blocks
+    def prepare_revision
+      return if new_record?
+      if (respond_to?(:fragments_attributes_changed) && fragments_attributes_changed) ||
+        !(changed & revision_fields).empty?
+        self.revision_data = revision_fields.each_with_object({}) do |field, c|
+          c[field] = send("#{field}_was")
+        end
+      end
+    end
+
+    # Revision is created only if relevant data changed
+    def create_revision
+      return unless revision_data
+
+      limit = ComfortableMexicanSofa.config.revisions_limit.to_i
+
+      # creating revision
+      if limit != 0
+        revisions.create!(data: revision_data)
+      end
+
+      # blowing away old revisions
+      ids = [0] + revisions.order(created_at: :desc).limit(limit).pluck(:id)
+      revisions.where("id NOT IN (?)", ids).destroy_all
+    end
+
+    # Assigning whatever is found in revision data and attempting to save the object
+    def restore_from_revision(revision)
+      return unless revision.record == self
+      update!(revision.data)
+    end
+
+  end
+
+end
+
+ActiveSupport.on_load :active_record do
+  include ComfortableMexicanSofa::HasRevisions
+end

data/lib/comfortable_mexican_sofa/form_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class ComfortableMexicanSofa::FormBuilder < ComfyBootstrapForm::FormBuilder
+
+  # Renders form input for a fragment
+  #
+  # @param [Comfy::Cms::Page] record
+  # @param [ComfortableMexicanSofa::Content::Tag] tag
+  # @param [Integer] index
+  def fragment_field(tag, index)
+    tag.form_field(object_name, @template, index) do |tag_input|
+      name = "#{object_name}[fragments_attributes][#{index}][identifier]"
+      identifer_input = @template.hidden_field_tag(name, tag.identifier, id: nil)
+
+      name  = "#{object_name}[fragments_attributes][#{index}][tag]"
+      value = tag.class.to_s.demodulize.underscore
+      tag_name_input = @template.hidden_field_tag(name, value, id: nil)
+
+      label = I18n.t("comfy.cms.content.tag.#{tag.identifier}", default: tag.identifier.titleize)
+      renderable = tag.respond_to?(:renderable) ? tag.renderable : true
+
+      form_group bootstrap: { label: { text: label, for: tag.form_field_id, class: "renderable-#{renderable}" } } do
+        concat identifer_input
+        concat tag_name_input
+        concat tag_input
+      end
+    end
+  end
+
+  # Wrapper for form action that is sticking to the bottom of the viewport.
+  # Example:
+  #   = form.form_actions do
+  #     = form.submit
+  #
+  def form_actions
+    content_tag(:div, class: "form-actions row bg-light") do
+      content_tag(:div, class: "col-lg-8 offset-lg-2") do
+        content_tag(:div, class: "form-group row mb-0") do
+          content_tag(:div, class: "col-sm-10 offset-sm-2") do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/comfortable_mexican_sofa/render_methods.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ComfortableMexicanSofa::RenderMethods
+
+  def self.included(base)
+    # If application controller doesn't have template associated with it
+    # CMS will attempt to find one. This is so you don't have to explicitly
+    # call render cms_page: '/something'
+    base.rescue_from "ActionView::MissingTemplate" do |e|
+      begin
+        render cms_page: request.path
+      rescue ComfortableMexicanSofa::MissingPage, ComfortableMexicanSofa::MissingSite
+        raise e
+      end
+    end
+  end
+
+  # Now you can render cms_page simply by calling:
+  #   render cms_page: '/path/to/page'
+  # This way application controllers can use CMS content while populating
+  # instance variables that can be used in partials (that are included by
+  # by the cms page and/or layout)
+  #
+  # Or how about not worrying about setting up CMS pages and rendering
+  # application view using a CMS layout?
+  #   render cms_layout: 'layout_slug', cms_fragments: {
+  #     fragment_identifier_a: 'content text',
+  #     fragment_identifier_b: {template: 'path/to/template' },
+  #     fragment_identifier_c: {partial:  'path/to/partial' }
+  #   }
+  #
+  # This way you are populating page block content and rendering
+  # an instantialized CMS page.
+  #
+  # Site is loaded automatically based on the request. However you can force
+  # it by passing :cms_site parameter with site's slug. For example:
+  #   render cms_page: '/path/to/page', cms_site: 'default'
+  #
+  def render(options = {}, locals = {}, &block)
+    return super unless options.is_a?(Hash)
+
+    if (site_identifier = options.delete(:cms_site))
+      unless (@cms_site = Comfy::Cms::Site.find_by_identifier(site_identifier))
+        raise ComfortableMexicanSofa::MissingSite, site_identifier
+      end
+    end
+
+    if (page_path = options.delete(:cms_page)) || (layout_identifier = options.delete(:cms_layout))
+      unless @cms_site ||= Comfy::Cms::Site.find_site(request.host_with_port.downcase, request.fullpath)
+        raise ComfortableMexicanSofa::MissingSite, "#{request.host.downcase}/#{request.fullpath}"
+      end
+    end
+
+    if page_path
+      render_cms_page(page_path, options, locals, &block)
+    elsif layout_identifier
+      render_cms_layout(layout_identifier, options, locals, &block)
+    else
+      super
+    end
+  end
+
+  def render_cms_page(path, options = {}, locals = {}, &block)
+    path.gsub!(%r{^/#{@cms_site.path}}, "") if @cms_site.path.present?
+
+    unless (@cms_page = @cms_site.pages.find_by_full_path(path))
+      raise ComfortableMexicanSofa::MissingPage, path
+    end
+
+    @cms_page.translate!
+
+    @cms_layout = @cms_page.layout
+    if (cms_fragments = options.delete(:cms_fragments)).present?
+      cms_fragments.each do |identifier, value|
+        content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+        page_fragment = @cms_page.fragments.detect { |f| f.identifier == identifier.to_s } ||
+                        @cms_page.fragments.build(identifier: identifier.to_s)
+        page_fragment.content = content
+      end
+    end
+    cms_app_layout = @cms_layout.app_layout
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = @cms_page.render
+
+    render(options, locals, &block)
+  end
+
+  def render_cms_layout(identifier, options = {}, locals = {}, &block)
+    unless (@cms_layout = @cms_site.layouts.find_by_identifier(identifier))
+      raise ComfortableMexicanSofa::MissingLayout, identifier
+    end
+
+    cms_app_layout = @cms_layout.app_layout
+    cms_page = @cms_site.pages.build(layout: @cms_layout)
+    cms_fragments =
+      options.delete(:cms_fragments) || { content: render_to_string({ layout: false }.merge(options)) }
+
+    cms_fragments.each do |frag_identifier, value|
+      content = value.is_a?(Hash) ? render_to_string(value.merge(layout: false)) : value.to_s
+      cms_page.fragments.build(identifier: frag_identifier.to_s, content: content)
+    end
+    options[:layout] ||= cms_app_layout.blank? ? nil : cms_app_layout
+    options[:inline] = cms_page.render
+
+    render(options, locals, &block)
+  end
+
+end
+
+ActiveSupport.on_load :action_controller_base do
+  include ComfortableMexicanSofa::RenderMethods
+end

data/lib/comfortable_mexican_sofa/routes/cms.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ActionDispatch::Routing::Mapper
+
+  def comfy_route_cms(options = {})
+    ComfortableMexicanSofa.configuration.public_cms_path = options[:path]
+
+    scope module: :comfy, as: :comfy do
+      namespace :cms, path: options[:path] do
+        get "cms-css/:site_id/:identifier(/:cache_buster)" => "assets#render_css", as: "render_css"
+        get "cms-js/:site_id/:identifier(/:cache_buster)"  => "assets#render_js",  as: "render_js"
+
+        get "(*cms_path)" => "content#show", as: "render_page", action: "/:format"
+      end
+    end
+  end
+
+end

data/lib/comfortable_mexican_sofa/routes/cms_admin.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class ActionDispatch::Routing::Mapper
+
+  def comfy_route_cms_admin(path: "admin")
+    scope module: :comfy, as: :comfy do
+      scope module: :admin do
+        namespace :cms, as: :admin_cms, path: path, except: :show do
+          get "/", to: "base#jump"
+
+          concern :with_revisions do |options|
+            resources :revisions, options.merge(only: %i[index show]) do
+              patch :revert, on: :member
+            end
+          end
+
+          concern :with_reorder do
+            put :reorder, on: :collection
+          end
+
+          concern :with_form_fragments do
+            get :form_fragments, on: :member
+          end
+
+          resources :sites do
+            resources :pages do
+              concerns :with_reorder
+              concerns :with_form_fragments
+              concerns :with_revisions, controller: "revisions/page"
+
+              get :toggle_branch,  on: :member
+
+              resources :translations, except: [:index] do
+                concerns :with_form_fragments
+                concerns :with_revisions, controller: "revisions/translation"
+              end
+            end
+
+            resources :files, concerns: [:with_reorder]
+
+            resources :layouts do
+              concerns :with_reorder
+              concerns :with_revisions, controller: "revisions/layout"
+            end
+
+            resources :snippets do
+              concerns :with_reorder
+              concerns :with_revisions, controller: "revisions/snippet"
+            end
+
+            resources :categories
+          end
+        end
+      end
+    end
+  end
+
+end