forest_cms 0.98.1

data/app/models/import.rb

@@ -0,0 +1,43 @@
+require 'csv'
+
+class Import
+  attr_reader :klass, :file
+
+  def initialize(klass, file)
+    @klass = klass
+    @file = file
+
+    validate_import
+
+    # TODO: initialize import job instead of doing import here
+    perform!
+  end
+
+  def perform!
+    # TODO: this creates a new object per CSV row. It may be worth optimizing further to use
+    # something like this approach to do only a single insert.
+    # https://gist.github.com/jackrg/76ade1724bd816292e4e
+    CSV.foreach(file.tempfile,
+                headers: true,
+                encoding:'iso-8859-1:utf-8',
+                skip_blanks: true,
+                skip_lines: /^(?:,\s*)+$/,
+                header_converters: -> (f) { f.strip },
+                converters: -> (f) { f ? f.strip : nil } ) do |row|
+      attrs = row.to_h.compact
+      klass.find_or_create_by!(attrs)
+    end
+  end
+
+  private
+
+    def validate_import
+      unless file.content_type == 'text/csv'
+        raise "Import must be a .csv file."
+      end
+
+      unless klass.present?
+        raise "A valid model must be supplied to the import."
+      end
+    end
+end

data/app/models/media_item.rb

@@ -0,0 +1,136 @@
+class MediaItem < Forest::ApplicationRecord
+  include Rails.application.routes.url_helpers
+  include Attachable
+  include Forest::CacheBuster
+  include Sluggable
+
+  DATE_FILTER_CACHE_KEY = 'forest_media_item_dates_for_filter'
+  CONTENT_TYPE_CACHE_KEY = 'forest_media_item_content_types_for_filter'
+
+  validates_attachment_presence :attachment
+
+  before_validation :set_default_metadata
+
+  after_commit :expire_cache
+
+  has_many :pages, foreign_key: :featured_image_id
+
+  enum media_item_status: {
+    not_hidden: 0,
+    hidden: 1
+  }
+
+  scope :by_date, -> (date) {
+    begin
+      date = Date.parse(date)
+      where('media_items.created_at >= ? AND media_items.created_at <= ?', date.beginning_of_month, date.end_of_month)
+    rescue ArgumentError => e
+      date = nil
+    end
+  }
+
+  def self.resource_description
+    'Media items consist of image, video and other file uploads.'
+  end
+
+  def self.dates_for_filter
+    Rails.cache.fetch DATE_FILTER_CACHE_KEY do
+      self.grouped_by_year_month.collect { |x| [x.created_at.strftime('%B %Y'), x.created_at.strftime('%d-%m-%Y')] }.reverse
+    end
+  end
+
+  def self.content_types_for_filter
+    Rails.cache.fetch CONTENT_TYPE_CACHE_KEY do
+      self.grouped_by_content_type.collect { |x| x.attachment_content_type }
+    end
+  end
+
+  def self.expire_cache!
+    Rails.cache.delete self::DATE_FILTER_CACHE_KEY
+    Rails.cache.delete self::CONTENT_TYPE_CACHE_KEY
+  end
+
+  def generate_slug
+    if self.slug.blank? || changed.include?('slug')
+      if title.present?
+        slug_attribute = title
+      elsif attachment_file_name.present?
+        slug_attribute = attachment_file_name
+      else
+        slug_attribute = SecureRandom.uuid
+      end
+
+      slug_attribute = slug_attribute.parameterize
+
+      if MediaItem.where(slug: slug_attribute).present?
+        slug_attribute = slug_attribute + '-' + SecureRandom.uuid
+      end
+
+      self.slug = slug_attribute
+    end
+  end
+
+  def glyphicon
+    if image?
+      'glyphicon-picture'
+    elsif video?
+      'glyphicon-play'
+    elsif attachment_content_type == 'application/zip'
+      'glyphicon-folder-close'
+    else
+      'glyphicon-file'
+    end
+  end
+
+  def to_jq_upload
+    {
+      'id': self.id,
+      'name': read_attribute(:title),
+      'file_name': attachment_file_name,
+      'is_image': image?,
+      'glyphicon': glyphicon,
+      'size': attachment.size,
+      'url': edit_admin_media_item_path(self),
+      'thumbnail_url': attachment.url(:medium),
+      'delete_url': admin_media_item_path(id: id),
+      'delete_type': 'DELETE'
+    }
+  end
+
+  # Portrait images have a lower aspect ratio
+  def aspect_ratio
+    dimensions[:width].to_f / dimensions[:height].to_f
+  end
+
+  def landscape?(ratio = 1)
+    aspect_ratio > ratio
+  end
+
+  def portrait?(ratio = 1)
+    !landscape?(ratio)
+  end
+
+  def to_select2_response
+    img_tag = "<img src='#{attachment.url(:thumb)}' style='height: 50px;'> " if image? && attachment.present?
+    "#{img_tag}<span class='select2-response__id'>#{id}</span> #{to_label}"
+  end
+
+  def to_select2_selection
+    img_tag = "<img src='#{attachment.url(:thumb)}' style='height: 20px; display: inline-block; vertical-align: top;'> " if image? && attachment.present?
+    "#{img_tag}<span class='select2-response__id'>#{id}</span> #{to_label}"
+  end
+
+  private
+
+    def self.grouped_by_year_month
+      self.select("DISTINCT ON (DATE_TRUNC('month', media_items.created_at)) *")
+    end
+
+    def self.grouped_by_content_type
+      self.select("DISTINCT ON (media_items.attachment_content_type) *")
+    end
+
+    def expire_cache
+      self.class.expire_cache!
+    end
+end

data/app/models/menu.rb

@@ -0,0 +1,65 @@
+class Menu < Forest::ApplicationRecord
+  include Sluggable
+
+  CACHE_KEY = 'forest_menus'
+
+  after_commit :expire_cache
+
+  validates :title, presence: true
+
+  def self.for(slug)
+    self.menus.select { |menu| menu.slug == slug.to_s }.first
+  end
+
+  def self.expire_cache!
+    Rails.cache.delete CACHE_KEY
+  end
+
+  def self.resource_description
+    "Menus are where you edit the navigation structure of your website. Menu items are composed of custom links or associations with pages."
+  end
+
+  def structure_as_json
+    JSON.parse(structure.presence || '[]')
+  end
+
+  def nokogiri
+    @nokogiri ||= begin
+      fragment = Nokogiri::HTML.fragment('<ul></ul>')
+      structure_as_json.each do |menu_item|
+        create_nokogiri_children(menu_item, fragment.at_css('ul'))
+      end
+      fragment
+    end
+  end
+
+  def render
+    nokogiri.to_html.html_safe
+  end
+
+  private
+
+    def self.menus
+      @memo ||= Rails.cache.fetch CACHE_KEY do
+        self.all.to_a
+      end
+    end
+
+    def self.reset_method_cache!
+      @memo = nil
+    end
+
+    def expire_cache
+      self.class.expire_cache!
+    end
+
+    def create_nokogiri_children(menu_item, node)
+      node.add_child("<li><a href='#{menu_item['url']}'>#{menu_item['name']}</a></li>")
+      if menu_item['children'].present?
+        node.css('> li').last.add_child('<ul></ul>')
+        menu_item['children'].each do |menu_item_child|
+          create_nokogiri_children(menu_item_child, node.css('> li').last.css('> ul').last)
+        end
+      end
+    end
+end

data/app/models/page.rb

@@ -0,0 +1,154 @@
+class Page < Forest::ApplicationRecord
+  include Blockable
+  include Statusable
+  # include Versionable
+
+  before_validation :generate_slug
+  before_validation :generate_path, if: :hierarchy_changed?
+
+  after_save :touch_associated_pages, if: :hierarchy_changed?
+  after_save :expire_menu_cache
+  after_save :touch_self
+
+  after_destroy :remove_page_hierarchy!
+
+  validates_presence_of :title
+  validates_presence_of :slug
+  validates_presence_of :path
+  validates_uniqueness_of :slug, scope: :parent_page_id
+  validates_uniqueness_of :path
+  validate :parent_page_is_not_self
+
+  has_many :immediate_children, -> { by_title }, class_name: 'Page', foreign_key: 'parent_page_id'
+
+  belongs_to :featured_image, class_name: 'MediaItem', optional: true
+  belongs_to :parent_page, class_name: 'Page', optional: true
+
+  scope :by_parent_page, -> (orderer = :desc) { order("pages.parent_page_id #{orderer} NULLS #{orderer == :desc ? 'LAST' : 'FIRST'}, pages.title #{orderer}, pages.id ASC") }
+  scope :title_like, -> (string) { where('pages.title ILIKE ?', "%#{string}%") }
+  scope :parent_pages, -> { where(parent_page_id: nil).order(:title, :id) }
+  scope :non_parent_pages, -> { where('pages.parent_page_id IS NOT NULL').order(:title, :id) }
+
+  def self.resource_description
+    "Pages offer a flexible and modular way to present information."
+  end
+
+  def generate_slug
+    self.slug = title.parameterize if self.slug.blank?
+  end
+
+  def to_friendly_param
+    path
+  end
+
+  def page_ancestors
+    # TODO: these recursive function aren't performant and should be cached in the view
+    @_page_ancestors ||= begin
+      ancestors ||= []
+      page = self
+      parent = page.parent_page unless page.parent_page == page
+      while parent
+        ancestors << parent
+        page = parent
+        parent = page.try :parent_page
+      end
+      ancestors
+    end
+  end
+
+  def page_descendents
+    # TODO: these recursive function aren't performant and should be cached in the view
+    @_page_descendents ||= begin
+      descendents = []
+      children = self.immediate_children
+
+      while children.present?
+        descendents.concat children
+        children = children.collect(&:immediate_children).reject(&:blank?).flatten
+      end
+
+      descendents
+    end
+  end
+
+  def page_root
+    @_page_root ||= page_ancestors.find { |p| p.parent_page_id.nil? }
+  end
+
+  def descendent_of?(page_or_page_slug)
+    if page_or_page_slug.is_a?(Page)
+      page_ancestors.any? { |p| p == page_or_page_slug }
+    else
+      page_ancestors.any? { |p| p.slug == page_or_page_slug }
+    end
+  end
+
+  def all_associated_pages
+    @_all_associated_pages ||= page_ancestors.concat(page_ancestors.each.collect(&:page_descendents)).flatten
+  end
+
+  def remove_page_hierarchy!
+    pages_to_touch = Page.where(id: [self.id, *self.page_descendents.collect(&:id)])
+    self.immediate_children.update_all(parent_page_id: nil)
+    pages_to_touch.update_all(updated_at: DateTime.now)
+  end
+
+  def select2_format
+    ((page_ancestors.length + 1).times.collect{}.join('&mdash; ') + title).as_json
+  end
+
+  # Returns a collection of media items that represent the basic images on the page. Override this
+  # method in your host app if your pages often contain images stored under other attribute names.
+  def typical_media_items
+    media_item_ids = []
+    media_item_ids.push(featured_image_id) if featured_image_id.present?
+
+    blocks.each do |b|
+      media_item_ids.push(b.media_item_id) if b.try(:media_item_id).present?
+      media_item_ids.concat(b.media_item_ids) if b.try(:media_item_ids).present?
+    end
+
+    if media_item_ids.present?
+      MediaItem.where(id: media_item_ids.uniq)
+    else
+      MediaItem.none
+    end
+  end
+
+  private
+
+    def touch_associated_pages
+      Page.where(id: all_associated_pages.collect(&:id)).update_all(updated_at: DateTime.now)
+    end
+
+    def current_or_previous_changes
+      self.changed.presence || self.previous_changes.keys
+    end
+
+    def hierarchy_changed?
+      (current_or_previous_changes & %w(parent_page_id slug)).any?
+    end
+
+    def generate_path
+      if page_ancestors.any?
+        generated_path = "#{page_ancestors.reverse.collect(&:slug).join('/')}/#{self.slug}"
+      else
+        generated_path = self.slug
+      end
+      self.path = generated_path
+    end
+
+    def parent_page_is_not_self
+      if parent_page == self
+        errors.add :parent_page, "a parent page can't be assigned to itself."
+      end
+    end
+
+    def expire_menu_cache
+      Menu.expire_cache!
+    end
+
+    def touch_self
+      self.touch unless self.new_record?
+    end
+end

data/app/models/setting.rb

@@ -0,0 +1,142 @@
+class Setting < Forest::ApplicationRecord
+  include Sluggable
+
+  CACHE_KEY = 'forest_settings'
+  APPLICATION_CACHE_KEY = 'forest_application_cache_key'
+  DEFAULT_SETTINGS = %i(site_title description featured_image)
+  VALID_VALUE_TYPES = %w(text boolean image integer string)
+
+  after_commit :touch_associations
+  after_commit :expire_cache
+
+  def self.for(key)
+    self.get(key).try(:value)
+  end
+
+  def self.get(key)
+    self.settings.select { |setting| setting.slug == key.to_s }.first
+  end
+
+  def self.expire_cache!
+    Rails.cache.delete CACHE_KEY
+  end
+
+  def self.expire_application_cache_key!
+    Rails.cache.delete APPLICATION_CACHE_KEY
+  end
+
+  def self.application_cache_key
+    Rails.cache.fetch APPLICATION_CACHE_KEY do
+      SecureRandom.uuid
+    end
+  end
+
+  # Define setting values, value types, and descriptions in your i18n file using the following pattern:
+  # en:
+  #   forest:
+  #     settings:
+  #       banner_text:
+  #         forest_setting_value: true
+  #         forest_setting_value_type: boolean
+  #         forest_setting_description: 'Enable a site-wide banner'
+  def self.initialize_from_i18n
+    I18n.backend.send(:init_translations) unless I18n.backend.initialized?
+    settings_from_i18n = I18n.backend.send(:translations).dig(:en, :forest, :settings).presence || {}
+
+    # Destroy any settings that are no longer in the i18n initialization or default settings array, and have matching updated and created at timestamps.
+    # This means any settings that are added directly from the database will be deleted.
+    Setting.all.reject { |setting|
+      Array(Setting::DEFAULT_SETTINGS).concat(settings_from_i18n.keys).include?(setting.slug.to_sym)
+    }.each { |setting|
+      if setting.has_not_been_updated?
+        logger.info { "[Forest][Setting] Destroying obsolete setting for #{setting.slug}" }
+        setting.destroy
+      end
+    }
+
+    settings_from_i18n.each do |setting|
+      k = setting[0].to_s
+      v = setting[1]
+
+      if v.is_a?(Hash) && v.keys.include?(:forest_setting_value)
+        v = v[:forest_setting_value]
+        value_type_from_i18n = setting[1][:forest_setting_value_type] unless setting[1].try(:[], :forest_setting_value_type).nil?
+        description_from_i18n = setting[1][:forest_setting_description] unless setting[1].try(:[], :forest_setting_description).nil?
+
+        if VALID_VALUE_TYPES.none?(value_type_from_i18n)
+          logger.warn { "[Forest][Setting] Warning: invalid value type '#{value_type_from_i18n}' for #{setting}. Setting value type to text." }
+          value_type_from_i18n = 'text'
+        end
+      end
+
+      if value_type_from_i18n == 'boolean'
+        if [true, 'true'].any?(v)
+          v = 1
+        else
+          v = 0
+        end
+      end
+
+      if [k, v].all?(&:present?)
+        s = Setting.get(k)
+
+        if s.blank?
+          s = Setting.new(title: k.titleize, slug: k)
+        end
+
+        s.value = v
+        s.value_type = value_type_from_i18n unless value_type_from_i18n.nil?
+        s.description = description_from_i18n unless description_from_i18n.nil?
+
+        if s.new_record?
+          logger.info { "[Forest][Setting] Creating new setting for #{k}" }
+          s.save
+        elsif s.has_not_been_updated?
+          if s.changed?
+            logger.info { "[Forest][Setting] Updating value for setting key #{k}" }
+            s.update_columns(title: k.titleize, slug: k, value: v)
+            s.update_column(:value_type, value_type_from_i18n) unless value_type_from_i18n.nil?
+            s.update_column(:description, description_from_i18n) unless description_from_i18n.nil?
+          end
+        end
+      else
+        logger.warn { "[Forest][Setting] Warning: unable to create setting for #{setting}. Key or value is blank." }
+      end
+    end
+
+    expire_cache!
+  end
+
+  def self.resource_description
+    "Settings are where you define static values that are used throughout the site. For example the title of your website, the description, and other values."
+  end
+
+  def slug_as_key?
+    true
+  end
+
+  def has_not_been_updated?
+    updated_at == created_at
+  end
+
+  private
+
+    def self.settings
+      @memo ||= Rails.cache.fetch CACHE_KEY do
+        self.all.to_a
+      end
+    end
+
+    def self.reset_method_cache!
+      @memo = nil
+    end
+
+    def expire_cache
+      self.class.expire_cache!
+    end
+
+    # Pages may depend on settings and should be updated each time a setting is changed
+    def touch_associations
+      Page.update_all(updated_at: Time.now)
+    end
+end