comfortable_mexican_sofa 1.12.11 → 2.0.0

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

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

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

@@ -0,0 +1,29 @@
+module Comfy
+  module Admin
+    module CmsHelper
+
+      # Wrapper around ComfortableMexicanSofa::FormBuilder
+      def comfy_form_for(record, options = {}, &block)
+        options[:builder] = ComfortableMexicanSofa::FormBuilder
+        options[:layout] ||= :horizontal
+        bootstrap_form_for(record, 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
+
+    end
+  end
+end

data/app/helpers/comfy/cms_helper.rb

@@ -1,75 +1,54 @@
 module Comfy
   module CmsHelper
 
-    # Wrapper around ComfortableMexicanSofa::FormBuilder
-    def comfy_form_for(record, options = {}, &proc)
-      options[:builder] = ComfortableMexicanSofa::FormBuilder
-      options[:layout] ||= :horizontal
-      bootstrap_form_for(record, options, &proc)
+    # 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 && 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
 
-    # Injects some content somewhere inside cms admin area
-    def cms_hook(name, options = {})
-      ComfortableMexicanSofa::ViewHooks.render(name, self, options)
+    # 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
+      render inline: page.render([node])
     end
 
-    # Content of a snippet. Examples:
+    # Raw content of a snippet.
+    # Example:
     #   cms_snippet_content(:my_snippet)
-    #   <%= cms_snippet_content(:my_snippet) do %>
-    #     Default content can go here.
-    #   <% end %>
-    def cms_snippet_content(identifier, cms_site = @cms_site, &block)
+    def cms_snippet_content(identifier, cms_site = @cms_site)
       unless cms_site
         host, path = request.host_with_port.downcase, request.fullpath if respond_to?(:request) && request
         cms_site = Comfy::Cms::Site.find_site(host, path)
       end
-      return '' unless cms_site
-
-      snippet = cms_site.snippets.find_by_identifier(identifier)
-
-      if !snippet && block_given?
-        snippet = cms_site.snippets.create(
-          :identifier => identifier,
-          :label      => identifier.to_s.titleize,
-          :content    => capture(&block)
-        )
-      end
-
-      snippet ? snippet.content : ''
+      snippet = cms_site && cms_site.snippets.find_by_identifier(identifier)
+      return "" unless snippet
+      snippet.content
     end
 
-    # Same as cms_snippet_content but cms tags will be expanded
-    def cms_snippet_render(identifier, cms_site = @cms_site, &block)
-      return '' unless cms_site
-      content = cms_snippet_content(identifier, cms_site, &block)
-      render :inline => ComfortableMexicanSofa::Tag.process_content(
-        cms_site.pages.build, ComfortableMexicanSofa::Tag.sanitize_irb(content)
-      )
-    end
-
-    # Content of a page block. This is how you get content from page:field
-    # Example:
-    #   cms_block_content(:left_column, CmsPage.first)
-    #   cms_block_content(:left_column) # if @cms_page is present
-    def cms_block_content(identifier, blockable = @cms_page)
-      tag = blockable && (block = blockable.blocks.find_by_identifier(identifier)) && block.tag
-      return '' unless tag
-      tag.content
-    end
-
-    # For those times when we need to render content that shouldn't be renderable
-    # Example: {{cms:field}} tags
-    def cms_block_content_render(identifier, blockable = @cms_page)
-      tag = blockable && (block = blockable.blocks.find_by_identifier(identifier)) && block.tag
-      return '' unless tag
-      render :inline => ComfortableMexicanSofa::Tag.process_content(blockable, tag.content)
-    end
-
-    # Same as cms_block_content but with cms tags expanded
-    def cms_block_render(identifier, blockable = @cms_page)
-      tag = blockable && (block = blockable.blocks.find_by_identifier(identifier)) && block.tag
-      return '' unless tag
-      render :inline => ComfortableMexicanSofa::Tag.process_content(blockable, tag.render)
+    # 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)
+      content = cms_snippet_content(identifier, cms_site)
+      r = ComfortableMexicanSofa::Content::Renderer.new(Comfy::Cms::Page.new)
+      render inline: r.render(r.nodes(r.tokenize(content)))
     end
 
     # Wrapper to deal with Kaminari vs WillPaginate
@@ -78,8 +57,9 @@ module Comfy
       if defined?(WillPaginate)
         will_paginate collection
       elsif defined?(Kaminari)
-        paginate collection, :theme => 'comfy'
+        paginate collection, theme: "comfy"
       end
     end
+
   end
-end
+end

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

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

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

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

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

@@ -1,68 +1,52 @@
 class Comfy::Cms::File < ActiveRecord::Base
   self.table_name = 'comfy_cms_files'
 
-  IMAGE_MIMETYPES = %w(gif jpeg pjpeg png tiff).collect{|subtype| "image/#{subtype}"}
+  include Comfy::Cms::WithCategories
 
-  cms_is_categorized
+  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"}
+  }
 
-  attr_accessor :dimensions
+  # temporary place to store attachment
+  attr_accessor :file
 
-  has_attached_file :file, ComfortableMexicanSofa.config.upload_file_options.merge(
-    # dimensions accessor needs to be set before file assignment for this to work
-    :styles => lambda { |f|
-      if f.respond_to?(:instance) && f.instance.respond_to?(:dimensions)
-        (f.instance.dimensions.blank?? { } : { :original => f.instance.dimensions }).merge(
-          :cms_thumb => '100x75#'
-        ).merge(ComfortableMexicanSofa.config.upload_file_options[:styles] || {})
-      end
-    }
-  )
-  before_post_process :is_image?
+  has_one_attached :attachment
 
-  # -- Relationships --------------------------------------------------------
+  # -- Relationships -----------------------------------------------------------
   belongs_to :site
-  belongs_to :block
 
-  # -- Validations ----------------------------------------------------------
-  validates :site_id,
-    :presence   => true
-  validates_attachment_presence :file
-  do_not_validate_attachment_file_type :file
-
-  validates :file_file_name,
-    :uniqueness => {:scope => [:site_id, :block_id]}
-
-  # -- Callbacks ------------------------------------------------------------
-  before_save   :assign_label
+  # -- Callbacks ---------------------------------------------------------------
   before_create :assign_position
-  after_save    :reload_blockable_cache
-  after_destroy :reload_blockable_cache
-
-  # -- Scopes ---------------------------------------------------------------
-  scope :not_page_file, -> { where(:block_id => nil)}
-  scope :images,        -> { where(:file_content_type => IMAGE_MIMETYPES) }
-  scope :not_images,    -> { where('file_content_type NOT IN (?)', IMAGE_MIMETYPES) }
-
-  # -- Instance Methods -----------------------------------------------------
-  def is_image?
-    IMAGE_MIMETYPES.include?(file_content_type)
+  after_save :process_attachment
+
+  # -- Validations -------------------------------------------------------------
+  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)
+  }
+
+  # -- Instance Methods --------------------------------------------------------
+  def label
+    l = read_attribute(:label)
+    return l if l.present?
+    attachment.attached?? attachment.filename.to_s : nil
   end
 
 protected
 
-  def assign_label
-    self.label = self.label.blank?? self.file_file_name.gsub(/\.[^\.]*?$/, '').titleize : self.label
-  end
-
   def assign_position
     max = Comfy::Cms::File.maximum(:position)
     self.position = max ? max + 1 : 0
   end
 
-  def reload_blockable_cache
-    return unless self.block
-    b = self.block.blockable
-    b.class.name.constantize.where(:id => b.id).update_all(:content_cache => nil)
+  def process_attachment
+    return if @file.blank?
+    self.attachment.attach(@file)
   end
-
 end

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

@@ -0,0 +1,55 @@
+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?
+    self.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 self.tag == "file"
+      @files = [@files.first]
+      self.attachments.purge_later if self.attachments
+    end
+
+    self.attachments.attach(@files)
+  end
+end

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

@@ -2,35 +2,31 @@
 
 class Comfy::Cms::Layout < ActiveRecord::Base
   self.table_name = 'comfy_cms_layouts'
-  
+
   cms_acts_as_tree
-  cms_is_mirrored
   cms_has_revisions_for :content, :css, :js
-  
+
   # -- Relationships --------------------------------------------------------
   belongs_to :site
-  has_many :pages, :dependent => :nullify
-  
-  # -- Callbacks ------------------------------------------------------------
+  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 ----------------------------------------------------------
+
+  # -- Validations -------------------------------------------------------------
   validates :site_id,
-    :presence   => true
+    presence:   true
   validates :label,
-    :presence   => true
+    presence:   true
   validates :identifier,
-    :presence   => true,
-    :uniqueness => { :scope => :site_id },
-    :format     => { :with => /\A\w[a-z0-9_-]*\z/i }
-    
-  # -- Scopes ---------------------------------------------------------------
-  default_scope -> { order('comfy_cms_layouts.position') }
-  
-  # -- Class Methods --------------------------------------------------------
+    presence:   true,
+    uniqueness: {scope: :site_id},
+    format:     {with: /\A\w[a-z0-9_-]*\z/i}
+
+  # -- Class Methods -----------------------------------------------------------
   # Tree-like structure for layouts
   def self.options_for_select(site, layout = nil, current_layout = nil, depth = 0, spacer = '. . ')
     out = []
@@ -43,7 +39,7 @@ class Comfy::Cms::Layout < ActiveRecord::Base
     end
     return out.compact
   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|
@@ -51,46 +47,55 @@ class Comfy::Cms::Layout < ActiveRecord::Base
         filename.gsub!("#{full_path}/layouts/", '')
         filename.split('/').last[0...1] == '_' ? nil : filename.split('.').first
       end.compact.sort
-    end.compact.sort
+    end.compact.uniq.sort
   end
-  
-  # -- Instance Methods -----------------------------------------------------
-  # magical merging tag is {cms:page:content} If parent layout has this tag
-  # defined its content will be merged. If no such tag found, parent content
-  # is ignored.
-  def merged_content
+
+  # -- Instance Methods --------------------------------------------------------
+  # Tokenized layout content that also pulls in parent layout (if there's one)
+  # and merges on the {{cms:fragment 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(self.content)
     if parent
-      regex = /\{\{\s*cms:page:content:?(?:(?::text)|(?::rich_text))?\s*\}\}/
-      if parent.merged_content.match(regex)
-        parent.merged_content.gsub(regex, content.to_s)
-      else
-        content.to_s
+      fragment_tags = ComfortableMexicanSofa::Content::Tag::Fragment.subclasses.map do |c|
+        c.to_s.demodulize.underscore
+      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(/\s/).first == "content"
+      end
+      if replacement_position
+        parent_tokens[replacement_position] = tokens
+        tokens = parent_tokens.flatten
       end
-    else
-      content.to_s
     end
+
+    return tokens
   end
 
   def cache_buster
     updated_at.to_i
   end
-  
+
 protected
-  
+
   def assign_label
     self.label = self.label.blank?? self.identifier.try(:titleize) : self.label
   end
-  
+
   def assign_position
     return if self.position.to_i > 0
-    max = self.site.layouts.where(:parent_id => self.parent_id).maximum(:position)
+    max = self.site.layouts.where(parent_id: self.parent_id).maximum(:position)
     self.position = max ? max + 1 : 0
   end
-  
+
   # Forcing page content reload
   def clear_page_content_cache
-    Comfy::Cms::Page.where(:id => self.pages.pluck(:id)).update_all(:content_cache => nil)
+    Comfy::Cms::Page.where(id: self.pages.pluck(:id)).update_all(content_cache: nil)
     self.children.each{ |child_layout| child_layout.clear_page_content_cache }
   end
-  
 end