forest_cms 0.98.1

data/app/helpers/navigation_helper.rb

@@ -0,0 +1,18 @@
+module NavigationHelper
+
+  def subnav
+    # TODO: cache subnav
+    if parent.present?
+      parent_page = Page.find_by_path(parent)
+      children = parent_page.immediate_children
+      render 'shared/subnav', items: children if children.any?
+    end
+  end
+
+  private
+
+    def parent
+      request.path.split('/').reject(&:blank?)[-2]
+    end
+
+end

data/app/helpers/status_indicator_helper.rb

@@ -0,0 +1,7 @@
+module StatusIndicatorHelper
+  def status_indicator(record)
+    content_tag(:span, '',
+      class: "status-indicator status-indicator--#{record.status}",
+      title: "Page status: #{t(record.status, scope: [:forest, :admin, record.model_name.singular, :status])}")
+  end
+end

data/app/inputs/block_selector_input.rb

@@ -0,0 +1,16 @@
+class BlockSelectorInput < SimpleForm::Inputs::CollectionSelectInput
+  def input(wrapper_options)
+    input_options[:hint] ||= 'Select a block from blocks on this page. You\'ll need to save the page after adding new blocks for them to appear in this list.'
+
+    if object.try(:anchor).present?
+      input_html_options[:data] ||= {}
+      input_html_options[:data]['selected'] = object.anchor
+    end
+
+    super
+  end
+
+  def collection
+    []
+  end
+end

data/app/inputs/collage_input.rb

@@ -0,0 +1,63 @@
+class CollageInput < SimpleForm::Inputs::CollectionSelectInput
+
+  def label(wrapper_options)
+    false
+  end
+
+  def input(wrapper_options = nil)
+    content = ActiveSupport::SafeBuffer.new
+    obj = input_html_options.fetch :object, object
+    input_html_options.merge! id: object_name.parameterize
+
+    associated_records = obj.send(reflection_or_attribute_name)
+
+    if object.new_record?
+      field_name = input_html_options.fetch(:field_name, "#{input_html_options[:id]}") << SecureRandom.hex
+    else
+      field_name = input_html_options.fetch :field_name, "#{input_html_options[:id]}"
+    end
+
+    cocoon_content = ActiveSupport::SafeBuffer.new
+
+    @builder.simple_fields_for(reflection_or_attribute_name) do |f|
+      cocoon_content << template.render('admin/form_inputs/collage/media_item_fields', f: f, obj: obj)
+    end
+
+    if associated_records.blank?
+      cocoon_content << template.content_tag(:div, 'Click the "Add collage item" button below to add images to this collage.', class: 'collage-input__empty-canvas-message')
+    end
+
+    canvas_styles = []
+
+    if object.try(:collage_height_ratio).present?
+      canvas_styles << "height: 0"
+      canvas_styles << "padding-bottom: #{object.collage_height_ratio}%"
+    end
+
+    cocoon_content = template.content_tag(:div, cocoon_content, class: "collage-input__canvas", id: "#{field_name}_preview", style: canvas_styles.join('; '))
+    cocoon_content = template.content_tag(:div, cocoon_content, class: "row")
+
+    content << template.content_tag(:div, cocoon_content, class: "collage-input__canvas-wrapper well")
+
+    cocoon_link = template.link_to_add_association('Add collage item',
+                                                   @builder,
+                                                   reflection_or_attribute_name,
+                                                   class: 'collage-input__link-to-add-association btn btn-default',
+                                                   partial: 'admin/form_inputs/collage/media_item_fields',
+                                                   render_options: {
+                                                     locals: {
+                                                       obj: obj
+                                                     }
+                                                   },
+                                                   data: {
+                                                    association_insertion_node: "##{field_name}_preview",
+                                                    association_insertion_method: 'append' })
+
+    content << template.content_tag(:div, cocoon_link, class: 'collage-input__cocoon-links links')
+
+    content << @builder.hidden_field(:collage_height_ratio, class: 'collage-input__input--height-ratio')
+
+    content
+  end
+
+end

data/app/inputs/color_input.rb

@@ -0,0 +1,30 @@
+class ColorInput < SimpleForm::Inputs::Base
+  def input(wrapper_options)
+    hex_code = object.try(attribute_name).presence || options.delete(:hex_code).presence || options.delete(:default).presence || default_hex_code
+    merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+    merged_input_options.merge!(type: :color, value: hex_code)
+
+    content = ActiveSupport::SafeBuffer.new
+    content << content_tag(:div, input_group(hex_code, merged_input_options), class: 'input-group')
+    content << content_tag(:div, default_help_text)
+    content
+  end
+
+  private
+
+    def input_group(hex_code, merged_input_options)
+      "#{@builder.text_field(attribute_name, merged_input_options)}#{input_group_addon(hex_code)}".html_safe
+    end
+
+    def default_help_text
+      content_tag :p, 'Click to select a color, or enter a 6 digit hex code in the box.', class: 'help-block'
+    end
+
+    def input_group_addon(hex_code)
+      "<input value='#{hex_code}' type='text' maxlength='7' name='color-input-hex-tracker' class='color-input__hex-tracker input-group-addon'>".html_safe
+    end
+
+    def default_hex_code
+      '#000000'
+    end
+end

data/app/inputs/currency_input.rb

@@ -0,0 +1,22 @@
+class CurrencyInput < SimpleForm::Inputs::Base
+  def input(wrapper_options)
+    currency = options.delete(:currency) || default_currency
+    merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
+    content_tag(:div, input_group(currency, merged_input_options), class: "input-group")
+  end
+
+  private
+
+    def input_group(currency, merged_input_options)
+      "#{currency_addon(currency)} #{@builder.number_field(attribute_name, merged_input_options)}".html_safe
+    end
+
+    def currency_addon(currency)
+      content_tag(:span, currency, class: "input-group-addon")
+    end
+
+    def default_currency
+      "$"
+    end
+end

data/app/inputs/datepicker_input.rb

@@ -0,0 +1,19 @@
+class DatepickerInput < SimpleForm::Inputs::StringInput
+  def input(wrapper_options = nil)
+    placeholder = options.delete(:placeholder) || 'Click to choose a date'
+
+    input_html_options[:data] ||= {}
+    input_html_options[:data][:datepicker] = true
+    input_html_options[:data][:blank] = options.delete(:blank)
+
+    if column.type == :datetime
+      input_html_options[:data][:timepicker] = true
+      input_html_options[:data][:timezone_utc_offset] = Time.zone.now.utc_offset
+    end
+
+    input_html_options[:placeholder] = placeholder
+    input_html_options[:autocomplete] = 'off'
+
+    super
+  end
+end

data/app/inputs/gallery_input.rb

@@ -0,0 +1,67 @@
+class GalleryInput < SimpleForm::Inputs::CollectionSelectInput
+
+  def label(wrapper_options)
+    if options[:label]
+      super
+    else
+      false
+    end
+  end
+
+  def input(wrapper_options = nil)
+    obj = input_html_options.fetch :object, object
+    input_html_options.merge! id: object_name.parameterize
+
+    associated_records = obj.send(reflection_or_attribute_name)
+
+    field_name = input_html_options.fetch :field_name, "#{input_html_options[:id]}"
+
+    placeholder = options[:placeholder] || 'Click here to add images to this gallery.'
+
+    selected_images = template.render(partial: 'admin/media_items/media_item_grid_layout', collection: associated_records, as: :media_item, cached: true)
+
+    modal_data_attributes = {
+      toggle: 'modal',
+      target: '.media-item-chooser',
+      multiple: true,
+      media_item_input: "##{field_name}",
+      media_item_modal_path: template.admin_media_items_path
+    }
+
+    modal_data_attributes_for_preview = selected_images.present? ? {} : modal_data_attributes
+
+    if selected_images.blank?
+      images_or_placeholder = template.content_tag(:div, placeholder, class: 'text-center')
+    else
+      images_or_placeholder = selected_images
+    end
+
+    preview_html = template.content_tag(:div, images_or_placeholder, class: "media-gallery-preview row small-gutters", id: "#{field_name}_preview")
+
+    content = ActiveSupport::SafeBuffer.new
+
+    content << template.content_tag(:div,
+                                    preview_html,
+                                    class: "media-gallery-preview-wrapper #{selected_images.present? ? 'media-gallery-preview-wrapper--has-images' : 'media-gallery-preview-wrapper--no-images'} well",
+                                    data: {
+                                      **modal_data_attributes_for_preview})
+
+    content << template.content_tag(:button, 'Choose Images',
+                  type: 'button',
+                  class: "media-item-chooser__button btn btn-default",
+                  data: {
+                    **modal_data_attributes
+                  })
+
+    content << @builder.collection_select(attribute_name,
+              associated_records, :id, :title, { selected: associated_records&.collect(&:id) },
+              multiple: true,
+              id: field_name,
+              class: 'gallery__input',
+              hidden: true
+            )
+
+    content
+  end
+
+end

data/app/inputs/grouped_collection_select_input.rb

@@ -0,0 +1,19 @@
+# A saner alternative to SimpleForm's :grouped_select input type
+# https://makandracards.com/makandra/25205-a-saner-alternative-to-simpleform-s-grouped_select-input-type
+class GroupedCollectionSelectInput < SimpleForm::Inputs::GroupedCollectionSelectInput
+
+  def input(wrapper_options = nil)
+    group_by = options.delete(:group_by)
+
+    if group_by
+      grouped_collection = options[:collection].group_by(&group_by)
+
+      options[:collection] = grouped_collection
+      options[:group_method] = :last
+      options[:group_label_method] = :first
+    end
+
+    super
+  end
+
+end

data/app/inputs/image_input.rb

@@ -0,0 +1,82 @@
+class ImageInput < SimpleForm::Inputs::StringInput
+
+  def input(wrapper_options = nil)
+    obj = input_html_options.fetch :object, object
+    input_html_options.merge! id: object_name.parameterize
+    image_object = obj.send(reflection_or_attribute_name)
+    img_src = input_html_options.fetch :img_src, image_object.try(:attachment).try(:url, :medium)
+    attribute_name_to_use = reflection.present? ? "#{reflection.name}_id" : attribute_name
+    media_item_type = image_object.try(:display_content_type).presence || 'media item'
+    button_title = input_html_options.fetch :button_title, "Choose #{media_item_type}"
+    compact = options.fetch(:compact, false)
+
+    # TODO: clean this craziness up
+    if img_src.nil? && obj.respond_to?(self.input_type)
+      img_src = obj.send(self.input_type).try(:attachment).try(:url, :medium)
+    end
+    path_only    = input_html_options.fetch :path_only, false
+    field_name   = input_html_options.fetch :field_name, "#{input_html_options[:id]}"
+
+    modal_data_attributes = {
+      toggle: 'modal',
+      target: '.media-item-chooser',
+      media_item_input: "##{field_name}",
+      media_item_modal_path: template.admin_media_items_path
+    }
+
+    # TODO: DF 08/04/17 - clarify what this is intened to do... and refactor ImageInput
+    path_class = (path_only ? 'media-item-chooser-to-path' : '')
+
+    image_tag_classes = []
+    image_tag_classes << path_class
+    image_tag_classes << (img_src.blank? ? 'hidden' : '')
+    image_tag_classes = image_tag_classes.join(' ')
+
+    content = ActiveSupport::SafeBuffer.new
+    buttons = ActiveSupport::SafeBuffer.new
+
+    if image_object.try(:file?) && !image_object.try(:video?)
+      content << template.content_tag(:div,
+                    nil,
+                    class: "media-item-chooser__image media-item-chooser__image--file img-rounded cursor-pointer glyphicon glyphicon-file #{image_tag_classes}",
+                    id: "#{field_name}_preview",
+                    data: {
+                      **modal_data_attributes
+                    })
+      content << template.text_field_tag('File URL', image_object.attachment.try(:url), readonly: true, class: 'form-control string')
+      content << template.tag(:br)
+    else
+      content << template.image_tag((img_src || ''),
+                    class: "media-item-chooser__image img-rounded cursor-pointer #{image_tag_classes}",
+                    id: "#{field_name}_preview",
+                    data: {
+                      **modal_data_attributes
+                    })
+    end
+
+    buttons << template.content_tag(:button, button_title,
+                  type: 'button',
+                  class: "media-item-chooser__button btn btn-default #{path_class}",
+                  data: {
+                    **modal_data_attributes
+                  })
+
+    buttons << template.content_tag(:button, "Remove #{media_item_type}",
+                  type: 'button',
+                  class: "media-item-chooser__remove-image btn btn-default #{'hidden' unless image_object.present?}")
+
+    if image_object.try(:id).present?
+      buttons << template.link_to("Edit #{media_item_type}",
+                    template.edit_admin_media_item_path(id: image_object.id),
+                    class: "media-item-chooser__edit-image btn btn-default",
+                    target: '_blank')
+    end
+
+    content << template.content_tag(:div, buttons, class: 'image__btn-group btn-group', role: 'group')
+
+    content << @builder.hidden_field(attribute_name_to_use, input_html_options) unless path_only
+
+    template.content_tag(:div, content, class: "image-input__body image-input__body--compact-#{compact.present?}")
+  end
+
+end

data/app/inputs/repeater_input.rb

@@ -0,0 +1,58 @@
+class RepeaterInput < SimpleForm::Inputs::TextInput
+  def input(wrapper_options = nil)
+    merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
+    content = ActiveSupport::SafeBuffer.new
+    content << '<div class="repeater__group-wrapper">'.html_safe
+    content << repeater_group_fields(options)
+    content << '</div>'.html_safe
+    content << content_tag(:div, "Add #{attribute_name.to_s.humanize.downcase}", class: 'repeater__add-item-button btn btn-default')
+    content << content_tag(:div, '', class: 'repeater__template', data: { template: repeater_group_fields(as_template: true) })
+    content
+  end
+
+  private
+
+    def repeater_group_fields(options = {})
+      repeater_group_fields = ActiveSupport::SafeBuffer.new
+      repeatable_records = object.send(attribute_name)
+      if repeatable_records.try(:blank?) || options[:as_template]
+        repeater_group_fields << '<div class="repeater__group panel panel-default">'.html_safe
+        repeater_group_fields << '<div class="repeater__group__body panel-body">'.html_safe
+        repeater_group_fields << key_input
+        repeater_group_fields << value_input
+        repeater_group_fields << '</div>'.html_safe
+        repeater_group_fields << repeater_controls
+        repeater_group_fields << '</div>'.html_safe
+      else
+        repeatable_records&.each do |row|
+          repeater_group_fields << '<div class="repeater__group panel panel-default">'.html_safe
+          repeater_group_fields << '<div class="repeater__group__body panel-body">'.html_safe
+          repeater_group_fields << key_input(row[:key])
+          repeater_group_fields << value_input(row[:value])
+          repeater_group_fields << '</div>'.html_safe
+          repeater_group_fields << repeater_controls
+          repeater_group_fields << '</div>'.html_safe
+        end
+      end
+      repeater_group_fields
+    end
+
+    def key_input(key = nil)
+      content_tag(:div, template.text_field_tag("#{object.model_name.singular}[#{attribute_name}][][key]", key, class: 'form-control', required: true), class: 'form-group')
+    end
+
+    def value_input(value = nil)
+      content_tag(:div, template.text_area_tag("#{object.model_name.singular}[#{attribute_name}][][value]", value, class: 'form-control', required: true), class: 'form-group')
+    end
+
+    def repeater_controls
+      controls = ActiveSupport::SafeBuffer.new
+      controls << '<div class="repeater__controls">'.html_safe
+      controls << '<div class="repeater__controls__buttons">'.html_safe
+      controls << content_tag(:div, '', class: 'repeater__controls__add-row-button repeater__controls__button btn btn-default btn-xs glyphicon glyphicon-plus')
+      controls << content_tag(:div, '', class: 'repeater__controls__remove-row-button repeater__controls__button btn btn-default btn-xs glyphicon glyphicon-minus')
+      controls << '</div>'.html_safe
+      controls << '</div>'.html_safe
+    end
+end

data/app/jobs/forest/application_job.rb

@@ -0,0 +1,4 @@
+module Forest
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/forest/application_mailer.rb

@@ -0,0 +1,6 @@
+module Forest
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,13 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  # Add the following code to your app's ApplicationRecord to update the application
+  # wide cache key.
+  after_commit :expire_application_cache_key
+
+  private
+
+  def expire_application_cache_key
+    Setting.expire_application_cache_key!
+  end
+end

data/app/models/block_kind.rb

@@ -0,0 +1,54 @@
+class BlockKind < Forest::ApplicationRecord
+  has_many :block_slots, inverse_of: :block_kind
+
+  scope :by_name, -> (orderer = :asc) { order(name: orderer, id: :desc) }
+
+  # TODO: - set up a BlockKind has_many blocks association?
+  #       - when destroying a BlockKind, also destroy all associated blocks?
+
+  def self.block_kind_params
+    self.all.collect do |block_kind|
+      block_kind.block.permitted_params + [:id, :_destroy]
+    end
+  end
+
+  def self.resource_description
+    "A block kind represents the different types of blocks that may be used to add content to a page."
+  end
+
+  def block
+    @block ||= self.name.constantize
+  end
+
+  def display_name
+    block.display_name
+  end
+
+  def to_label
+    display_name
+  end
+
+  def display_icon
+    block.display_icon
+  end
+
+  def to_select2_response
+    r = ''
+    r << '<div>'
+    r << "<span class='block-kind__select2-response__icon #{display_icon}'></span> "
+    r << '<strong>'
+    r << display_name
+    r << '</strong>'
+    r << '</div>'
+
+    if description.present?
+      r << '<div class="text-muted">'
+      r << '<smaller>'
+      r << description
+      r << '</smaller>'
+      r << '</div>'
+    end
+
+    r
+  end
+end