forest_cms 0.98.1

data/app/models/block_layout.rb

@@ -0,0 +1,19 @@
+class BlockLayout < Forest::ApplicationRecord
+  include Sluggable
+
+  has_many :block_slots, inverse_of: :block_layout
+
+  validates_presence_of :display_name
+
+  def self.resource_description
+    "A block layout is a grouping of blocks that may appear in a particular part of the page. For example, you may have block layouts that apply to the sidebar or header areas of a page."
+  end
+
+  def self.default_layout
+    BlockLayout.find_by_slug('default')
+  end
+
+  def slug_attribute
+    display_name
+  end
+end

data/app/models/block_slot.rb

@@ -0,0 +1,49 @@
+class BlockSlot < Forest::ApplicationRecord
+  parent_class = self
+
+  validates_presence_of :block_kind
+  validates :block_record, presence: true, on: :update
+
+  belongs_to :block, polymorphic: true, dependent: :destroy
+  belongs_to :block_record, polymorphic: true #, optional: true
+  belongs_to :block_kind, inverse_of: :block_slots
+  belongs_to :block_layout, inverse_of: :block_slots
+
+  before_validation :create_block_if_block_attributes_empty
+
+  accepts_nested_attributes_for :block, reject_if: :all_blank, allow_destroy: true
+
+  scope :by_layout, -> (block_layout) { where(block_layout_id: block_layout.id) }
+
+  # Merge these blockable params into the blockable record's strong params
+  def self.blockable_params
+    {
+      block_slots_attributes: [
+        :id, :_destroy, :position,
+        :block_type, :block_record_type,
+        :block_id, :block_kind_id, :block_layout_id, :block_record_id,
+        block_attributes: [*BlockKind.block_kind_params]
+      ]
+    }
+  end
+
+  def block_attributes=(attributes)
+    if BlockKind.where(name: self.block_kind.name).exists?
+      self.block ||= self.block_kind.name.constantize.new
+      self.block.assign_attributes(attributes)
+    end
+  end
+
+  def create_block_if_block_attributes_empty
+    if BlockKind.where(name: self.block_kind.name).exists? && BlockKind.where(name: self.block_kind.name).first.block.permitted_params.blank?
+      self.block ||= self.block_kind.name.constantize.new
+    end
+  end
+
+  protected
+
+    def build_block(kind = nil)
+      kind ||= self.block_kind.name.constantize
+      self.block = kind.new
+    end
+end

data/app/models/blocks/base_block.rb

@@ -0,0 +1,134 @@
+class BaseBlock < Forest::ApplicationRecord
+  self.abstract_class = true
+
+  has_one :block_slot,
+          as: :block,
+          inverse_of: :block,
+          class_name: 'BlockSlot',
+          dependent: :destroy
+
+  # Override to customize the display name of the block.
+  def self.display_name
+    'Base Block'
+  end
+
+  # Override to add a Bootstrap 3 glyphicon next to the block's title.
+  def self.display_icon
+    'glyphicon glyphicon-tree-conifer'
+  end
+
+  def self.kind
+    BlockKind.find_by_name(name)
+  end
+
+  def display_name
+    self.class.display_name
+  end
+
+  def hidden?
+    false
+  end
+
+  def block?
+    true
+  end
+
+  # Override to add css classes to a block's wrapper.
+  def css_class
+  end
+
+  # Override to add css styles to a block's wrapper.
+  def css_styles
+  end
+
+  # Override to add data attributes to a block's wrapper. Make sure this is a hash.
+  def data_attributes
+  end
+
+  def display_icon
+    self.class.display_icon
+  end
+
+  def permitted_params
+    self.class.permitted_params
+  end
+
+  def block_id
+    "#{self.model_name.singular.dasherize}-#{self.id}"
+  end
+
+  def block_kind
+    @block_kind ||= BlockKind.find_by_name(self.class.name)
+  end
+
+  def block_record
+    @block_record ||= block_slot.block_record
+  end
+
+  def block_record_id
+    block_record.block_record.id
+  end
+
+  def block_layout
+    block_slot.block_layout
+  end
+
+  def blocks
+    block_record.blocks(block_layout: block_layout)
+  end
+
+  def index
+    blocks.index(self)
+  end
+
+  def first?
+    index == 0
+  end
+
+  def last?
+    index == blocks.length - 1
+  end
+
+  def first_of_kind?
+    blocks.first_of_kind(self.class) == self
+  end
+
+  def last_of_kind?
+    blocks.last_of_kind(self.class) == self
+  end
+
+  def even_of_kind?
+    blocks.kind(self.class).index(self).even?
+  end
+
+  def odd_of_kind?
+    blocks.kind(self.class).index(self).odd?
+  end
+
+  def previous
+    return nil if first?
+    blocks[index - 1]
+  end
+
+  def next
+    return nil if last?
+    blocks[index + 1]
+  end
+
+  def non_indexed_attributes
+    %W(id created_at updated_at)
+  end
+
+  # Override this in your block to define which attributes should be indexed for search
+  def indexed_attributes
+    self.class.columns.select { |c| %i(text string).include?(c.type) }
+           .collect(&:name)
+           .reject { |c| c =~ /_url$/ } - non_indexed_attributes
+  end
+
+  def as_indexed_json(options={})
+    self.as_json({
+      only: indexed_attributes
+    })
+  end
+end

data/app/models/cache_record.rb

@@ -0,0 +1,2 @@
+class CacheRecord < ApplicationRecord
+end

data/app/models/concerns/attachable.rb

@@ -0,0 +1,126 @@
+module Attachable
+  extend ActiveSupport::Concern
+
+  included do
+    has_attached_file :attachment,
+                        styles: {
+                          thumb: '200x200#',
+                          small: '600x600>',
+                          medium: '1200x1200>',
+                          large: '2000x2000>'
+                        },
+                        convert_options: {
+                          thumb:  lambda { |r| r.gif? ? '' : '-unsharp 0x1' },
+                          small:  lambda { |r| r.gif? ? '' : '-unsharp 0x1' },
+                          medium: lambda { |r| r.gif? ? '' : '-unsharp 1.5x1+0.7+0.02' },
+                          large:  lambda { |r| r.gif? ? '' : '-unsharp 1.5x1+0.7+0.02' },
+                          all:    lambda { |r| r.gif? ? '-strip -auto-orient -colorspace sRGB' : '-strip -auto-orient -quality 85 -colorspace sRGB -interlace Plane -sampling-factor 4:2:0' }
+                        },
+                        default_url: '/images/:style/missing.png'
+
+      do_not_validate_attachment_file_type :attachment
+
+      before_post_process :skip_for_non_images
+      before_post_process :rename_attachment
+      after_post_process :extract_dimensions
+      after_post_process :collect_garbage
+
+      serialize :dimensions
+
+      belongs_to :attachable, polymorphic: true, optional: true
+
+      scope :by_content_type, -> (content_type) { where(attachment_content_type: content_type) }
+      scope :images, -> { where('attachment_content_type LIKE ?', '%image%') }
+      scope :videos, -> { where('attachment_content_type LIKE ?', '%video%') }
+      scope :pdfs, -> { where('attachment_content_type LIKE ?', '%pdf%') }
+
+      def large_attachment_url
+        attachment.url(:large)
+      end
+
+      def image?
+        (attachment_content_type =~ %r{^(image|(x-)?application)/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$}).present?
+      end
+
+      def video?
+        (attachment_content_type =~ %r{^video\/}).present?
+      end
+
+      def file?
+        !image?
+      end
+
+      def gif?
+        attachment_content_type == 'image/gif'
+      end
+
+      def display_content_type
+        if image?
+          'image'
+        elsif video?
+          'video'
+        elsif file?
+          'file'
+        else
+          'media item'
+        end
+      end
+
+      def dimensions_at(size)
+        geometry = attachment.options[:styles][size].split('x')
+        w = geometry.first.to_f
+        ratio = dimensions[:width] / w
+
+        {
+          width: dimensions[:width] / ratio,
+          height: dimensions[:height] / ratio
+        }
+      end
+
+      def file_extension
+        File.extname(attachment_file_name).downcase
+      end
+
+      def display_file_name
+        attachment_file_name.sub(/(--\d*)?#{Regexp.quote(file_extension)}$/i, '')
+      end
+
+      private
+
+        def set_default_metadata
+          if self.title.blank?
+            self.title = display_file_name
+          end
+        end
+
+        # Append a timestamp to the end of the file name to avoid cache issues with a CDN, e.g. CloudFront.
+        def rename_attachment
+          self.attachment.instance_write(:file_name, "#{display_file_name}--#{Time.now.to_i}#{file_extension}")
+        end
+
+        def skip_for_non_images
+          image?
+        end
+
+        # Retrieves dimensions for image assets
+        # @note Do this after resize operations to account for auto-orientation.
+        # https://github.com/thoughtbot/paperclip/wiki/Extracting-image-dimensions
+        def extract_dimensions
+          return unless image?
+          tempfile = attachment.queued_for_write[:original]
+          unless tempfile.nil?
+            geometry = Paperclip::Geometry.from_file(tempfile)
+            self.dimensions = {
+              width: geometry.width.to_i,
+              height: geometry.height.to_i
+            }
+          end
+        end
+
+        # Not sure if this is a good idea, but Heroku's memory gets bogged down immediately
+        # when using paperclip and imagemagick.
+        def collect_garbage
+          GC.start
+        end
+  end
+end

data/app/models/concerns/blockable.rb

@@ -0,0 +1,65 @@
+module Blockable
+  extend ActiveSupport::Concern
+
+  included do
+    parent_class = self
+
+    before_save :touch_self
+    after_save :set_blockable_metadata
+
+    has_many :block_slots, -> { order(:position) },
+             as: :block_record,
+             inverse_of: :block_record,
+             foreign_key: 'block_record_id',
+             dependent: :destroy
+
+    accepts_nested_attributes_for :block_slots, allow_destroy: true
+
+    def self.blockable?
+      true
+    end
+
+    def blockable?
+      true
+    end
+
+    def blocks(options = {})
+      block_layout = options.fetch(:block_layout, nil)
+      block_layout_name = block_layout.try(:slug).try(:underscore).presence || 'default'
+      block_type = options.fetch(:kind, nil)
+
+      instance_variable_get("@#{block_layout_name}_blocks") || instance_variable_set("@#{block_layout_name}_blocks", begin
+        if block_type
+          b = block_slots.includes(:block).where(block_kind_id: block_type.kind.id)
+        else
+          b = block_slots.includes(:block, :block_layout)
+        end
+        if block_layout.present?
+          b = b.select { |bs| bs.block_layout == block_layout }
+        end
+        Forest::BlockSet.new b.collect(&:block)
+      end)
+    end
+
+    def featured_image_from_blocks
+      blocks.find { |b| b.try(:media_item).present? }.try(:media_item)
+    end
+
+    private
+
+      def touch_self
+        if self.respond_to?(:updated_at)
+          self.updated_at = Time.now
+        end
+      end
+
+      # Blockable metadata is a way to cache and store data on the blockable record itself to avoid expensive database lookups
+      # when querying information about a record that may come from the reord's blocks.
+      def set_blockable_metadata
+        if self.respond_to?(:blockable_metadata)
+          self.blockable_metadata['featured_image_url'] = featured_image_from_blocks.try(:attachment).try(:url, :large)
+          self.update_column(:blockable_metadata, self.blockable_metadata)
+        end
+      end
+  end
+end

data/app/models/concerns/filter_controller_scopes.rb

@@ -0,0 +1,13 @@
+module FilterControllerScopes
+  extend ActiveSupport::Concern
+
+  included do
+    has_scope :by_id
+    has_scope :by_title
+    has_scope :by_slug
+    has_scope :by_created_at
+    has_scope :by_updated_at
+    has_scope :by_status
+    has_scope :fuzzy_search
+  end
+end

data/app/models/concerns/forest/cache_buster.rb

@@ -0,0 +1,112 @@
+# Include the CacheBuster concern in a model to automatically update
+# all of a model's associated records (hopefully).
+#
+# There are only two hard things in Computer Science: cache invalidation and naming things.
+# -- Phil Karlton
+
+module Forest::CacheBuster
+  extend ActiveSupport::Concern
+
+  included do
+    after_save :touch_associations
+    after_save :touch_dependent_records
+    after_destroy :touch_associations
+    after_destroy :touch_dependent_records
+
+    # A cached set of associations is stored in a polymorphic record after every save.
+    # This allows us to know what the previous set of associated records was during a
+    # record's after_save callback, which is important when associations are removed.
+    has_one :cache_record, as: :cacheable, dependent: :destroy
+
+    private
+
+      def touch_associations
+        # Find all relevant associations
+        has_many_associations = self.class.reflect_on_all_associations(:has_many)
+        habtm_many_associations = self.class.reflect_on_all_associations(:has_and_belongs_to_many)
+        all_associations = has_many_associations + habtm_many_associations
+
+        # Collect a set of associated records (ActiveRecord::Associations objects)
+        association_groups = all_associations.collect { |association| self.send(association.plural_name) }
+
+        to_update = {}
+        time_now = Time.now
+
+        # Find the cache_record or build a new one
+        cache_record = cache_record.presence || self.build_cache_record
+
+        # Extract the associated class name and ids from the cache_record
+        if cache_record.data.present?
+          cache_record.data.each do |cache_record_item|
+            klass = cache_record_item['klass']
+            id = cache_record_item['id']
+            to_update[klass] ||= []
+            to_update[klass] << id
+          end
+        end
+
+        # Update the associations currently attached to the record
+        association_groups.each do |records|
+          if records.try :any?
+            if records.class.parent.name == 'ActiveRecord::Associations'
+              if records.column_names.include?('updated_at')
+                logger.debug { "[Forest] CacheBuster is updating associations for #{records.length} #{records.first.model_name.plural}" }
+                records.unscope(:order).update_all updated_at: time_now
+                # Expire model cache_key
+                records.klass.name.safe_constantize&.try(:expire_cache_key)
+              end
+
+              # Delete record ids from the to_update hash if we update them here
+              records.to_a.flatten.each do |record|
+                to_update[record.class.name] ||= []
+                to_update[record.class.name].delete(record.id)
+              end
+            end
+          end
+        end
+
+        # Check all associations and see if they are blocks. If they are, collect the unique associated
+        # block records and touch each one.
+        associated_blocks = association_groups.flatten.select { |r| r.try(:block?) }
+        if associated_blocks.present?
+          associated_blocks.collect(&:block_record).uniq.each do |block_record|
+            logger.debug { "[Forest] CacheBuster is updating block_record #{block_record.class.to_s} that was associated with a block." }
+            block_record.touch
+          end
+        end
+
+        # Update any remaining associations
+        to_update.each do |class_name, ids|
+          klass = class_name.safe_constantize
+          next unless klass.present?
+          records = klass.where(id: ids)
+          if records.present?
+            if records.column_names.include?('updated_at')
+              logger.debug { "[Forest] CacheBuster is updating remaining associations for #{records.length} #{records.first.model_name.plural} inferred from the cache_record" }
+              records.unscope(:order).update_all(updated_at: time_now)
+              # Expire model cache_key
+              klass.try(:expire_cache_key)
+            end
+          end
+        end
+
+        # Store the new set of associations in the cache_record
+        cache_record.data = association_groups.flatten.collect do |record|
+          { klass: record.class.name, id: record.id }
+        end
+
+        # Save the cache_record
+        cache_record.save
+      end
+
+      # In some situations a block might rely on data that isn't associated via an ActiveRecord
+      # Association. For example, a CurrentExhibitions block depends on Exhibition, but doesn't rely
+      # on an association. In that case, override this method in the model and bust the associated data
+      # as necessary, using something like the commented out code here.
+      def touch_dependent_records
+        # For example:
+        # logger.debug { "[Forest] CacheBuster is touching dependent records for #{'CurrentExhibitionsBlock'.safe_constantize.length} CurrentExhibitionsBlocks" }
+        # 'CurrentExhibitionsBlock'.safe_constantize&.update_all(updated_at: Time.now)
+      end
+  end
+end