forest_cms 0.98.1

data/app/models/concerns/searchable.rb

@@ -0,0 +1,200 @@
+# This module provides a search interface to the record using elasticsearch-rails.
+# The easiest way to implement search in your host app deployed on heroku is to
+# add the 'bonsai-elasticsearch-rails' gem, and include this Searchable concern
+# in the models you want to index.
+#
+# Does not support Elasticsearch version > 5
+# TODO: Once the elasticsearch/rails gems make it easier to use version 6, make this
+# Searchable concern compatible.
+#
+# You'll want to look at the SearchIndexManager class next for information on how to customize
+# the elasticsearch indices for your models.
+#
+# Once your model is configured, import documents with the rake task:
+# `bin/rails forest:elasticsearch:rebuild`
+
+begin
+  require 'elasticsearch/model'
+  require 'elasticsearch/rails'
+rescue LoadError
+end
+
+module Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+
+    index_name SearchIndexManager::INDEX_NAME
+
+    # TODO: as an improvement implement Asynchronous Callbacks
+    # https://github.com/elastic/elasticsearch-rails/tree/master/elasticsearch-model#asynchronous-callbacks
+
+    after_commit on: [:create] do
+      begin
+        index_elasticsearch_document if indexable_for_elasticsearch?
+      rescue Exception => e
+        logger.warn { "[Forest][Searchable] Failed to index document #{self.class} #{self.id} #{e.inspect}" }
+      end
+    end
+
+    after_commit on: [:update] do
+      begin
+        if indexable_for_elasticsearch?
+          index_elasticsearch_document
+        else
+          delete_elasticsearch_document
+        end
+      rescue Exception => e
+        logger.warn { "[Forest][Searchable] Failed to index document #{self.class} #{self.id} #{e.inspect}" }
+      end
+    end
+
+    after_commit on: [:destroy] do
+      begin
+        delete_elasticsearch_document
+      rescue Exception => e
+        logger.warn { "[Forest][Searchable] Failed to delete document #{self.class} #{self.id} #{e.inspect}" }
+      end
+    end
+
+    def self.searchable?
+      true
+    end
+
+    # Override this in your host app with the scope method to use when importing elasticsearch documents. This
+    # should probably match the conditions of the indexable_for_elasticsearch? method.
+    def self.elasticsearch_import_model_scope
+      if self.respond_to?(:statusable?)
+        :published
+      end
+    end
+
+    def self.elasticsearch(query)
+      __elasticsearch__.search(query)
+    end
+
+    def self.non_indexed_attributes
+      %W(id slug path status scheduled_date created_at updated_at featured_image_id parent_page_id redirect)
+    end
+    def non_indexed_attributes
+      self.class.non_indexed_attributes
+    end
+
+    def self.indexed_attributes
+      columns.select { |c| %i(text string).include?(c.type) }
+             .collect(&:name)
+             .reject { |c| c =~ /_url$/ } - non_indexed_attributes
+    end
+    def indexed_attributes
+      self.class.indexed_attributes
+    end
+
+    def self.indexed_associations
+      if self.try(:blockable?)
+        {
+          block_slots: {
+            only: :block,
+            include: {
+              block: {
+                methods: [:as_indexed_json],
+                only: {
+                  methods: [:as_indexed_json]
+                }
+              }
+            }
+          }
+        }
+      end
+    end
+    def indexed_associations
+      self.class.indexed_associations
+    end
+
+    # def self.fields_to_search
+    #   indexed_attributes.collect { |a|
+    #     a =~ /name$/ ? "#{a}^2" : a
+    #   }.concat(indexed_associations_to_search)
+    # end
+
+    # Override in your host app model to specify field search and match behavior
+    def self.elasticsearch_query(query)
+      {
+        query: {
+          match: {
+            _all: sanitize_query(query)
+          }
+          # multi_match: {
+          #   query: sanitize_query(query),
+          #   fields: fields_to_search
+          # }
+        },
+        highlight: {
+          fields: { '*' => {} },
+          require_field_match: false,
+          pre_tags: ['|highlight|'],
+          post_tags: ['|/highlight|']
+        }
+      }
+    end
+
+    def self.sanitize_query(query)
+      return if query.blank?
+      memo_key = "@_sanitize_query_#{query.parameterize.underscore}"
+      return instance_variable_get(memo_key) if instance_variable_defined?(memo_key)
+      instance_variable_set memo_key, begin
+        # http://stackoverflow.com/a/16442439
+        # Escape special characters
+        # http://lucene.apache.org/core/old_versioned_docs/versions/2_9_1/queryparsersyntax.html#Escaping Special Characters
+        escaped_characters = Regexp.escape('\\\/+-&|!(){}[]^~*?:')
+        query = query.gsub(/([#{escaped_characters}])/, '\\\\\1')
+
+        # AND, OR and NOT are used by lucene as logical operators. We need
+        # to escape them
+        ['AND', 'OR', 'NOT'].each do |word|
+          escaped_word = word.split('').map {|char| "\\#{char}" }.join('')
+          query = query.gsub(/\s*\b(#{word.upcase})\b\s*/, " #{escaped_word} ")
+        end
+
+        # Escape odd quotes
+        quote_count = query.count '"'
+        query = query.gsub(/(.*)"(.*)/, '\1\"\3') if quote_count % 2 == 1
+
+        query
+      end
+    end
+
+    def searchable?
+      true
+    end
+
+    # Override this method if you need to customize the logic that determines
+    # if a record is published, or should be indexed for the public.
+    def indexable_for_elasticsearch?
+      if self.respond_to?(:statusable?)
+        self.try(:published?)
+      else
+        true
+      end
+    end
+
+    def as_indexed_json(options={})
+      self.as_json({
+        only: indexed_attributes,
+        include: indexed_associations
+      })
+    end
+  end
+
+  private
+
+    def index_elasticsearch_document
+      logger.debug { '[Forest][Searchable] Indexing document' }
+      __elasticsearch__.index_document
+    end
+
+    def delete_elasticsearch_document
+      logger.debug { '[Forest][Searchable] Deleting document' }
+      __elasticsearch__.delete_document ignore: 404
+    end
+end

data/app/models/concerns/sluggable.rb

@@ -0,0 +1,70 @@
+module Sluggable
+  extend ActiveSupport::Concern
+
+  included do
+    before_validation :generate_slug
+    before_save :parameterize_slug, if: :will_save_change_to_slug?
+
+    # validates :slug, presence: true, uniqueness: true
+
+    scope :by_slug, -> (orderer = :asc) { order(slug: orderer) }
+
+    def self.sluggable?
+      true
+    end
+
+    def sluggable?
+      true
+    end
+
+    # Override this method to define which attribute the slug is created from, or
+    # have this method return false to use a random slug
+    def slug_attribute
+      if respond_to?(:title)
+        title
+      elsif respond_to?(:name)
+        name
+      else
+        raise Forest::Error.new("Slug attribute :title does not exist on #{self.class.name}. Define a `slug_attribute` method with a valid attribue.")
+      end
+    end
+
+    def generate_slug
+      return unless generate_slug?
+
+      if slug_attribute.present?
+        slug_attr = slug_attribute.parameterize
+        if slug_as_key?
+          slug_attr = slug_attribute.parameterize.underscore
+        end
+      else
+        slug_attr = SecureRandom.uuid
+      end
+
+      self.slug = slug_attr
+
+      if self.class.find_by_slug(slug_attr).present?
+        self.slug = "#{slug_attr}-#{SecureRandom.uuid}"
+      end
+    end
+
+    def generate_slug?
+      self.slug.blank?
+    end
+
+    # Override slug_as_key? in models like settings where the slug should be underscored, not dasherized
+    def slug_as_key?
+      false
+    end
+
+    def to_friendly_param
+      slug
+    end
+
+    private
+
+      def parameterize_slug
+        self.slug = slug.parameterize
+      end
+  end
+end

data/app/models/concerns/statusable.rb

@@ -0,0 +1,71 @@
+module Statusable
+  extend ActiveSupport::Concern
+
+  # To make a record schedulable, create a date column named published_date
+  # TODO: remove references to scheduled_date in favor of published_date
+
+  included do
+    parent_class = self
+
+    enum status: {
+      published: 1,
+      # draft: 2,
+      scheduled: 3,
+      # pending: 4,
+      hidden: 5
+    }
+
+    validates_presence_of :status
+
+    before_save :set_status_by_published_date
+
+    scope :by_status, -> (status) { where(status: status) }
+    scope :published, -> { by_status(:published) }
+    scope :published_or_scheduled, -> {
+      where("#{parent_class.model_name.plural}.status = :published OR (#{parent_class.model_name.plural}.status = :scheduled AND COALESCE(#{parent_class.model_name.plural}.#{attribute_for_scheduled_date}, :date_yesterday) <= :date_today)",
+        published: 1,
+        scheduled: 3,
+        date_today: Date.today,
+        date_yesterday: Date.yesterday)
+    }
+
+    def self.statusable?
+      true
+    end
+
+    def self.statuses_for_select
+      if (self.column_names & ['scheduled_date', 'published_date']).present?
+        self.statuses
+      else
+        self.statuses.except(:scheduled)
+      end
+    end
+
+    def self.attribute_for_scheduled_date
+      if column_names.include?('scheduled_date')
+        :scheduled_date
+      elsif column_names.include?('published_date')
+        :published_date
+      end
+    end
+
+    def statusable?
+      true
+    end
+
+    private
+
+      def set_status_by_published_date
+        return if self.class.attribute_for_scheduled_date.blank?
+        return if self.send(self.class.attribute_for_scheduled_date).blank?
+
+        if self.respond_to?(self.class.attribute_for_scheduled_date)
+          if self.send(self.class.attribute_for_scheduled_date).present? && self.send(self.class.attribute_for_scheduled_date).to_date <= Date.today
+            self.status = self.scheduled? ? 'published' : self.status
+          else
+            self.status = self.published? ? 'scheduled' : self.status
+          end
+        end
+      end
+  end
+end

data/app/models/concerns/versionable.rb

@@ -0,0 +1,13 @@
+module Versionable
+  extend ActiveSupport::Concern
+
+  included do
+    def self.versionable?
+      true
+    end
+
+    def versionable?
+      true
+    end
+  end
+end

data/app/models/forest/application_record.rb

@@ -0,0 +1,111 @@
+require 'csv'
+
+module Forest
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    after_commit :expire_application_cache_key
+    after_commit :expire_cache_key
+
+    scope :by_id, -> (orderer = :desc) { order(id: orderer) }
+    scope :by_title, -> (orderer = :asc) { order(title: orderer, id: :desc) }
+    scope :by_created_at, -> (orderer = :desc) { order(created_at: orderer, id: orderer) }
+    scope :by_updated_at, -> (orderer = :desc) { order(updated_at: orderer, id: orderer) }
+    scope :fuzzy_search, -> (query) {
+      columns_to_search = self.columns
+                              .select { |x| [:string, :text].include?(x.type) }
+                              .map(&:name).collect { |x| "#{self.model_name.plural}.#{x} ILIKE :query" }
+      columns_to_search << "CAST(#{self.model_name.plural}.id AS TEXT) ILIKE :query"
+      where(columns_to_search.join(' OR '), query: "%#{sanitize_sql_like(query)}%")
+    }
+
+    def self.cache_key_name
+      "forest_all_#{model_name.plural}_cache_key"
+    end
+
+    def self.cache_key
+      Rails.cache.fetch self.cache_key_name do
+        SecureRandom.uuid
+      end
+    end
+
+    def self.csv_columns
+      valid_columns = self.columns.select { |a| valid_csv_column_types.include?(a.type) }
+      valid_columns.collect(&:name) - invalid_csv_column_names
+    end
+
+    def self.to_csv_template
+      CSV.generate(headers: true) do |csv|
+        csv << csv_columns
+      end
+    end
+
+    # Statusable default
+    def self.statusable?
+      false
+    end
+
+    def statusable?
+      false
+    end
+
+    # Versionable default
+    def self.versionable
+      false
+    end
+
+    def versionable
+      false
+    end
+
+    def self.expire_cache_key
+      Rails.cache.delete cache_key_name
+    end
+
+    def expire_cache_key
+      self.class.expire_cache_key
+    end
+
+    # Override this to define a friendly param attribute, like `slug` or `path`
+    def to_friendly_param
+      to_param
+    end
+
+    def to_label
+      if try(:display_name).present?
+        display_name
+      elsif try(:name).present?
+        name
+      elsif try(:title).present?
+        title
+      else
+        "#{self.model_name.human} #{id}"
+      end
+    end
+
+    def to_select2_response
+      if respond_to?(:media_item) && media_item.try(:attachment).present?
+        img_tag = "<img src='#{media_item.attachment.url(:thumb)}' style='height: 20px; display: inline-block; vertical-align: top;'> "
+      end
+      "#{img_tag}<span class='select2-response__id'>#{id}</span> #{to_label}"
+    end
+
+    def to_select2_selection
+      to_select2_response
+    end
+
+    private
+
+      def self.valid_csv_column_types
+        %i(integer text string boolean)
+      end
+
+      def self.invalid_csv_column_names
+        %w(id created_at updated_at status slug)
+      end
+
+      def expire_application_cache_key
+        Setting.expire_application_cache_key!
+      end
+  end
+end