comfy_middle_seat 3.2.0

data/lib/comfortable_media_surfer/content/tags/mixins/file_content.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# A mixin for tags that returns the file as their content.
+module ComfortableMediaSurfer::Content::Tags::Mixins
+  module FileContent
+    # @param [ActiveStorage::Blob] file
+    # @param ["link", "image", "url"] as
+    # @param [{String => String}] variant_attrs ImageMagick variant attributes
+    # @param [String] label alt text for `as: "image"`, link text for `as: "link"`
+    # @return [String]
+    def content(file: self.file, as: self.as, variant_attrs: self.variant_attrs, label: self.label)
+      return '' unless file
+
+      url_helpers = Rails.application.routes.url_helpers
+
+      attachment_url =
+        if variant_attrs.present? && file.image?
+          variant = file.variant(combine_options: variant_attrs)
+          url_helpers.rails_representation_path(variant, only_path: true)
+        else
+          url_helpers.rails_blob_path(file, only_path: true)
+        end
+
+      case as
+      when 'link'
+        "<a href='#{attachment_url}'#{html_class_attribute} target='_blank'>#{label}</a>"
+      when 'image'
+        "<img src='#{attachment_url}'#{html_class_attribute} alt='#{label}' title='#{label}'/>"
+      else
+        attachment_url
+      end
+    end
+
+  private
+
+    def html_class_attribute
+      return if @class.blank?
+
+      " class='#{@class}'"
+    end
+  end
+end

data/lib/comfortable_media_surfer/content/tags/number.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using number input
+#   {{ cms:number identifier }}
+#
+class ComfortableMediaSurfer::Content::Tags::Number < ComfortableMediaSurfer::Content::Tags::Fragment
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, class: 'form-control' }
+    input   = view.send(:number_field_tag, name, content, options)
+
+    yield input
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :number, ComfortableMediaSurfer::Content::Tags::Number
+)

data/lib/comfortable_media_surfer/content/tags/page_file_link.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'mixins/file_content'
+
+# This tag allows you to link page-level files from within the page content.
+#
+# E.g. if your layout has:
+#
+#   {{ cms:file graphic, render: false }}
+#   {{ cms:files attachments, redner: false }}
+#
+# You can link to the files from an individual page (or snippet rendered in
+# the context of the page) like so:
+#
+#   {{ cms:page_file_link graphic }}
+#   {{ cms:page_file_link attachments, filename: "cat.jpg" }}
+#
+# `as`      - url (default) | link | image - how file gets rendered out
+# `class`   - any html classes that you want on the result link or image tag. For example "class1 class2"
+#
+# - the following params are deprecated / not functional, perhaps due to some change in ImageMagick
+# - Simply use a class in your CSS / SASS to style your image display
+# `label`   - attach label attribute to link or image tag
+# `resize`  - imagemagick option. For example: "100x50>"
+# `gravity` - imagemagick option. For example: "center"
+# `crop`    - imagemagick option. For example: "100x50+0+0"
+#
+class ComfortableMediaSurfer::Content::Tags::PageFileLink < ComfortableMediaSurfer::Content::Tag
+  include ComfortableMediaSurfer::Content::Tags::Mixins::FileContent
+
+  # @return [String] A `cms:file(s)` identifier.
+  attr_reader :identifier
+
+  # @type ["url", "link", "image"]
+  attr_reader :as
+
+  # @type [{String => String}]
+  attr_reader :variant_attrs
+
+  # @return [String] Used to refer to a file in a {{ cms:files }} tag.
+  attr_reader :filename
+
+  # @param (see ComfortableMediaSurfer::Content::Tag#initialize)
+  def initialize(context:, params: [], source: nil)
+    super
+
+    options = params.extract_options!
+    @identifier     = params[0]
+    @as             = options['as'] || 'url'
+    @class          = options['class']
+    @variant_attrs  = options.slice('resize', 'gravity', 'crop')
+    @filename       = options['filename']
+
+    return if @identifier.present?
+
+    raise Error, 'Missing identifier for page file link tag'
+  end
+
+  # @return [Comfy::Cms::Fragment]
+  def fragment
+    @fragment ||= context.fragments.detect { |f| f.identifier == identifier }
+  end
+
+  # @return [ActiveStorage::Blob]
+  def file
+    @file ||=
+      if fragment.nil?
+        nil
+      elsif filename.nil?
+        fragment.attachments.first
+      else
+        fragment.attachments.detect { |a| a.filename.to_s == filename }
+      end
+  end
+
+  # @return [String]
+  def label
+    return if file.nil?
+
+    file.filename.to_s
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :page_file_link, ComfortableMediaSurfer::Content::Tags::PageFileLink
+)

data/lib/comfortable_media_surfer/content/tags/partial.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Tag for injecting partials. Example tag:
+#   {{cms:partial path/to/partial, foo: bar, zip: zoop}}
+# This expands into a familiar:
+#   <%= render partial: "path/to/partial", locals: {foo: bar, zip: zoop} %>
+# Whitelist is can be used to control what partials are renderable.
+#
+class ComfortableMediaSurfer::Content::Tags::Partial < ComfortableMediaSurfer::Content::Tag
+  attr_reader :path, :locals
+
+  def initialize(context:, params: [], source: nil)
+    super
+    @locals = params.extract_options!
+    @path   = params[0]
+
+    return if @path.present?
+
+    raise Error, 'Missing path for partial tag'
+  end
+
+  # we output erb into rest of the content
+  def allow_erb?
+    true
+  end
+
+  def content
+    format(
+      '<%%= render partial: %<path>p, locals: %<locals>s %%>',
+      path: @path,
+      locals: @locals
+    )
+  end
+
+  def render
+    whitelist = ComfortableMediaSurfer.config.allowed_partials
+    if whitelist.is_a?(Array)
+      whitelist.member?(@path) ? content : ''
+    else
+      content
+    end
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :partial, ComfortableMediaSurfer::Content::Tags::Partial
+)

data/lib/comfortable_media_surfer/content/tags/siblings.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Nav Tag for rendering previous and next sibling links relative to current page
+#   {{ cms:siblings }}
+#   {{ cms:siblings style: "font-style: italic", exclude: "404-page, search-page" }}
+# To customize your siblings style, add a 'siblings' id to your CSS, e.g
+# #siblings {
+#   color: #006633;
+#   font-size: 95%;
+#   margin-top: 12px;
+#   font-style: italic;
+# }
+# and/or pass in style overrides with the 'style' parameter (see above)
+#
+# To exclude siblings, list their slugs with the 'exclude' parameter
+# as comma-delimited string, e.g. as above - exclude: "404-page, search-page"
+#
+# style and exclude parameters are optional
+
+class ComfortableMediaSurfer::Content::Tags::Siblings < ComfortableMediaSurfer::Content::Tag
+  attr_reader :locals, :style, :sibs
+  attr_accessor :links
+
+  def initialize(context:, params: [], source: nil)
+    super
+    @locals = params.extract_options!
+    @style = ''
+    @style = "<style>#siblings {#{@locals['style']}}</style>" if @locals['style']
+    @exclude = []
+    @exclude = @locals['exclude'].split(',') if @locals['exclude']
+    @links = ''
+    # ActiveRecord_Associations_CollectionProxy
+    @sibs = context.self_and_siblings.order(:position).to_ary
+    unless Rails.env == 'development'
+      @sibs.delete_if { |sib| !sib.is_published }
+    end
+    @sibs.delete_if { |sib| @exclude.include? sib.slug }
+  end
+
+  def content
+    if @sibs.count > 1
+      @links = '<div id="siblings">'
+      prevp = false
+      @sibs.each do |sib|
+        sib_idx = @sibs.index(sib)
+        next if sib.slug == context.slug
+        next if Rails.env == 'production' && !sib.is_published
+        next unless @sibs.index(context) # current page is excluded
+
+        if sib_idx == @sibs.index(context) - 1
+          @links += "<a href=#{sib.url(relative: true)}>#{sib.label}</a> &laquo;&nbsp;<em>Previous</em> &bull; "
+          prevp = true
+        elsif sib_idx == @sibs.index(context) + 1
+          @links += '&bull;' unless prevp
+          @links += "<em>Next</em>&nbsp;&raquo; <a href=#{sib.url(relative: true)}>#{sib.label}</a>"
+        end
+      end
+      @links += '</div>'
+    end
+    "#{@style}#{@links}"
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :siblings, ComfortableMediaSurfer::Content::Tags::Siblings
+)

data/lib/comfortable_media_surfer/content/tags/snippet.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Tag for reusable snippets within context's site scope. Looks like this:
+#   {{cms:snippet identifier}}
+# Snippets may have more tags in them like fragments, so they may be expanded too.
+#
+class ComfortableMediaSurfer::Content::Tags::Snippet < ComfortableMediaSurfer::Content::Tag
+  attr_reader :identifier
+
+  def initialize(context:, params: [], source: nil)
+    super
+    @identifier = params[0]
+
+    return if @identifier.present?
+
+    raise Error, 'Missing identifier for snippet tag'
+  end
+
+  def content
+    if snippet.markdown
+      Kramdown::Document.new(snippet.content.to_s).to_html
+    else
+      snippet.content
+    end
+  end
+
+  # Grabbing or initializing Comfy::Cms::Snippet object
+  def snippet
+    context.site.snippets.detect { |s| s.identifier == identifier } ||
+      context.site.snippets.build(identifier: identifier)
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :snippet, ComfortableMediaSurfer::Content::Tags::Snippet
+)

data/lib/comfortable_media_surfer/content/tags/template.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Tag for injecting template rendering. Example tag:
+#   {{cms:template template/path}}
+# This expands into something like this:
+#   <%= render template: "template/path" %>
+# Whitelist is can be used to control what templates are available.
+#
+class ComfortableMediaSurfer::Content::Tags::Template < ComfortableMediaSurfer::Content::Tag
+  attr_reader :path
+
+  def initialize(context:, params: [], source: nil)
+    super
+    @path = params[0]
+
+    return if @path.present?
+
+    raise Error, 'Missing template path for template tag'
+  end
+
+  # we output erb into rest of the content
+  def allow_erb?
+    true
+  end
+
+  def content
+    format('<%%= render template: %<path>p %%>', path: path)
+  end
+
+  def render
+    whitelist = ComfortableMediaSurfer.config.allowed_templates
+    if whitelist.is_a?(Array)
+      whitelist.member?(@path) ? content : ''
+    else
+      content
+    end
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :template, ComfortableMediaSurfer::Content::Tags::Template
+)

data/lib/comfortable_media_surfer/content/tags/text.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using text input
+#   {{ cms:text identifier }}
+#
+class ComfortableMediaSurfer::Content::Tags::Text < ComfortableMediaSurfer::Content::Tags::Fragment
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, class: 'form-control' }
+    input   = view.send(:text_field_tag, name, content, options)
+
+    yield input
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :text, ComfortableMediaSurfer::Content::Tags::Text
+)

data/lib/comfortable_media_surfer/content/tags/textarea.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using textarea
+#   {{ cms:textarea identifier }}
+#
+
+class ComfortableMediaSurfer::Content::Tags::Textarea < ComfortableMediaSurfer::Content::Tags::Fragment
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, data: { 'cms-cm-mode' => 'text/html' } }
+    input   = view.send(:text_area_tag, name, content, options)
+
+    yield input
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :textarea, ComfortableMediaSurfer::Content::Tags::Textarea
+)

data/lib/comfortable_media_surfer/content/tags/wysiwyg.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Tag for text content that is going to be rendered using Redactor (default) in
+# the admin area
+#   {{ cms:wysiwyg identifier }}
+#
+#
+class ComfortableMediaSurfer::Content::Tags::Wysiwyg < ComfortableMediaSurfer::Content::Tags::Fragment
+  def form_field(object_name, view, index)
+    name    = "#{object_name}[fragments_attributes][#{index}][content]"
+    options = { id: form_field_id, data: { 'cms-rich-text' => true } }
+    input   = view.send(:text_area_tag, name, content, options)
+    yield input
+  end
+end
+
+ComfortableMediaSurfer::Content::Renderer.register_tag(
+  :wysiwyg, ComfortableMediaSurfer::Content::Tags::Wysiwyg
+)

data/lib/comfortable_media_surfer/content/tags.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Content::Tags
+  # ...
+end
+
+require_relative 'tags/fragment'
+require_relative 'tags/wysiwyg'
+require_relative 'tags/text'
+require_relative 'tags/textarea'
+require_relative 'tags/markdown'
+require_relative 'tags/datetime'
+require_relative 'tags/date'
+require_relative 'tags/number'
+require_relative 'tags/checkbox'
+require_relative 'tags/file'
+require_relative 'tags/files'
+require_relative 'tags/snippet'
+require_relative 'tags/asset'
+require_relative 'tags/file_link'
+require_relative 'tags/image'
+require_relative 'tags/page_file_link'
+require_relative 'tags/helper'
+require_relative 'tags/partial'
+require_relative 'tags/template'
+require_relative 'tags/audio'
+require_relative 'tags/breadcrumbs'
+require_relative 'tags/children'
+require_relative 'tags/siblings'

data/lib/comfortable_media_surfer/content.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Content
+  # ...
+end
+
+require_relative 'content/renderer'
+require_relative 'content/params_parser'
+require_relative 'content/tag'
+require_relative 'content/tags'
+require_relative 'content/block'

data/lib/comfortable_media_surfer/engine.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'comfortable_media_surfer'
+require 'rails'
+require 'rails-i18n'
+require 'comfy_bootstrap_form'
+require 'active_link_to'
+require 'kramdown'
+require 'haml-rails'
+
+module ComfortableMediaSurfer
+  class Engine < ::Rails::Engine
+    initializer 'comfortable_media_surfer.setup_assets' do |app|
+      app.config.assets.paths << root.join('app/assets/builds')
+      app.config.assets.precompile += %w[comfy/admin/cms/application.js comfy/admin/cms/application.css]
+    end
+
+    config.to_prepare do
+      Dir.glob("#{Rails.root}app/decorators/comfortable_media_surfer/*_decorator*.rb").each do |c|
+        require_dependency(c)
+      end
+    end
+  end
+end

data/lib/comfortable_media_surfer/error.rb

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

data/lib/comfortable_media_surfer/extensions/acts_as_tree.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Extensions::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 ComfortableMediaSurfer::Extensions::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 ComfortableMediaSurfer::Extensions::ActsAsTree
+end

data/lib/comfortable_media_surfer/extensions/has_revisions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Extensions::HasRevisions
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def cms_has_revisions_for(*fields)
+      include ComfortableMediaSurfer::Extensions::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.intersect?(revision_fields)
+        self.revision_data = revision_fields.to_h do |field|
+          [field, send("#{field}_was")]
+        end
+      end
+    end
+
+    # Revision is created only if relevant data changed
+    def create_revision
+      return unless revision_data
+
+      limit = ComfortableMediaSurfer.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 ComfortableMediaSurfer::Extensions::HasRevisions
+end

data/lib/comfortable_media_surfer/extensions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ComfortableMediaSurfer::Extensions
+  # ...
+end
+
+require_relative 'extensions/acts_as_tree'
+require_relative 'extensions/has_revisions'