fae-railsz 2.1.0

data/app/helpers/fae/application_helper.rb

@@ -0,0 +1,114 @@
+module Fae
+  module ApplicationHelper
+
+    def form_header(name)
+      name = name.class.name.split('::').last unless name.is_a? String
+      form_title = "#{params[:action]} #{name}".titleize
+      form_title = form_title.singularize if params[:action] == 'edit'
+      content_tag :h1, form_title
+    end
+
+    def require_locals(local_array, local_assigns)
+      local_array.each do |loc|
+        raise "#{loc} is a required local, please define it when you render this partial" unless local_assigns[loc.to_sym].present?
+      end
+    end
+
+    def nav_active_class(klass, level, idx, parent_idx = nil)
+      return klass unless @fae_navigation.coordinates[level] == idx
+      return klass unless parent_idx.blank? || @fae_navigation.coordinates[level-1] == parent_idx
+      new_klass = parent_idx.blank? ? '-parent-current -open' : '-current'
+      new_klass += " #{klass}" if klass.present?
+      new_klass
+    end
+
+    def col_name_or_image(item, attribute)
+      value = item.send(attribute)
+      return if value.blank?
+      # if item is an image
+      if value.class.name == 'Fae::Image'
+        image_tag(value.asset.thumb.url) if value.asset.thumb.url.present?
+      # if item's attribute is an association
+      elsif item.class.reflections.include?(attribute)
+        value.try(:fae_display_field)
+      # if item is a date or a time adjust to timezone
+      elsif value.is_a?(Date) || value.is_a?(ActiveSupport::TimeWithZone)
+        fae_date_format(value)
+      elsif value.is_a?(Time)
+        fae_datetime_format(value)
+      else
+        # otherwise it's an attribute so display it's value
+        value
+      end
+    end
+
+    def fae_scope
+      fae.root_path.gsub('/', '')
+    end
+
+    def page_title
+      if @page_title.present?
+        @page_title
+      else
+        default_page_title
+      end
+    end
+
+    def body_class
+      @body_class.present? ? @body_class : "#{controller_name} #{action_name}"
+    end
+
+    def change_item_link(change)
+      text = "#{change.changeable_type.gsub('Fae::','')}: "
+      test_source_method = :data_source_exists?
+
+      if change.changeable_type.exclude?('Fae') && change.changeable_type.exclude?('Page') && !ActiveRecord::Base.connection.send(test_source_method, change.changeable_type.tableize)
+        return "#{change.changeable_type}: model destroyed"
+      else
+        display_text = change.try(:changeable).try(:fae_display_field)
+        display_text = (display_text.is_a? Integer) ? display_text.to_s : display_text
+        text += display_text || "##{change.changeable_id}"
+
+        begin
+          return link_to text, fae.edit_content_block_path(change.changeable.slug) if change.changeable_type == 'Fae::StaticPage'
+          parent = change.changeable.respond_to?(:fae_parent) ? change.changeable.fae_parent : nil
+          edit_path = edit_polymorphic_path([main_app, fae_scope, parent, change.changeable])
+          return link_to text, edit_path
+        rescue
+          return text
+        end
+      end
+    end
+
+    private
+
+    def nav_path_current?(path)
+      current_page?(path) || path[1..-1].classify == params[:controller].classify
+    end
+
+    def default_page_title
+      pieces = [@option.title]
+      pieces << page_title_piece
+      pieces.join ' | '
+    end
+
+    def page_title_piece
+      return @page_title_piece if @page_title_piece.present?
+
+      action = params[:action].humanize.titleize unless params[:action] == 'index'
+      controller = controller_title unless params[:controller] == 'fae/pages'
+      controller = controller.singularize if params[:action] == 'new' || params[:action] == 'edit'
+
+      "#{action} #{controller}".strip
+    end
+
+    def controller_title
+      params[:controller].gsub(/fae\/|#{fae_scope}\//, '').humanize.titleize
+    end
+
+    def tr_id(item)
+      "#{item.class.name.underscore.gsub('/', '_').pluralize}_#{item.id}"
+    end
+
+  end
+end

data/app/helpers/fae/fae_helper.rb

@@ -0,0 +1,6 @@
+# DO NOT add methods to this helper
+# this empty helper is meant to be overridden in the parent app
+module Fae
+  module FaeHelper
+  end
+end

data/app/helpers/fae/form_helper.rb

@@ -0,0 +1,240 @@
+module Fae
+  module FormHelper
+
+    def fae_input(f, attribute, options={})
+      custom_options attribute, options
+      language_support f, attribute, options
+      label_and_hint attribute, options
+      list_order f, attribute, options
+      set_prompt f, attribute, options
+
+      add_input_class(options, 'js-markdown-editor') if options[:markdown].present?
+      add_input_class(options, 'js-html-editor') if options[:html].present?
+
+      set_maxlength(f, attribute, options)
+
+      f.input attribute, options
+    end
+
+    def fae_association(f, attribute, options={})
+      custom_options attribute, options
+      label_and_hint attribute, options
+      list_order f, attribute, options
+      set_prompt f, attribute, options if !options[:include_blank].is_a?(String)
+
+      f.association attribute, options
+    end
+
+    def fae_prefix(f, attribute, options={})
+      raise "Fae::MissingRequiredOption: fae_prefix helper method requires the 'prefix' option." if options[:prefix].blank?
+      symbol 'prefix', options[:prefix], options
+      fae_input f, attribute, options
+    end
+
+    def fae_suffix(f, attribute, options={})
+      raise "Fae::MissingRequiredOption: fae_suffix helper method requires the 'suffix' option." if options[:suffix].blank?
+      symbol 'suffix', options[:suffix], options
+      fae_input f, attribute, options
+    end
+
+    def fae_radio(f, attribute, options={})
+      options[:alignment] = 'radio_collection--horizontal' if options[:type] == 'inline'
+      options[:alignment] = 'radio_collection--vertical' if options[:type] == 'stacked' || options[:type].blank?
+      options.update(as: :radio_collection, wrapper_class: "#{options[:wrapper_class]} #{options[:alignment]}", no_label_div: true)
+      association_or_input f, attribute, options
+    end
+
+    def fae_checkbox(f, attribute, options={})
+      options[:type] ||= 'stacked'
+      options.update(as: :check_boxes, wrapper_class: "checkbox-wrapper js-checkbox-wrapper #{options[:wrapper_class]} -#{options[:type]}", no_label_div: true)
+      association_or_input f, attribute, options
+    end
+
+    def fae_pulldown(f, attribute, options={})
+      raise "Fae::MissingRequiredOption: fae_pulldown requires a 'collection' when using it on an ActiveRecord attribute." if !options.has_key?(:collection) && f.object.attribute_names.include?(attribute.to_s)
+      raise "Fae::ImproperOptionValue: The value #{options[:size]} is not a valid option for 'size'. Please use 'short' or 'long'." if options[:size].present? && ['short','long'].include?(options[:size]) == false
+      raise "Fae::ImproperOptionValue: The value #{options[:search]} is not a valid option for 'search'. Please use a Boolean." if options[:search].present? && !!options[:search] != options[:search]
+
+      add_input_class(options, 'small_pulldown') if options[:size] == "short"
+      add_input_class(options, 'select-search') if options[:search]
+      options.update(wrapper_class: "#{options[:wrapper_class]} select-no_search") if options[:search] == false
+      association_or_input f, attribute, options
+    end
+
+    def fae_multiselect(f, attribute, options={})
+      raise "Fae::'#{attribute}' must be an association of #{f.object}" if !is_association?(f, attribute)
+      raise "Fae::ImproperOptionValue: The value '#{options[:two_pane]}' is not a valid option for 'two_pane'. Please use a Boolean." if options[:two_pane].present? && !!options[:two_pane] != options[:two_pane]
+
+      options.update(input_class: "#{options[:input_class]} multiselect") if options[:two_pane] == true
+      fae_association f, attribute, options
+    end
+
+    def fae_datepicker(f, attribute, options={})
+      options.update(as: :string, wrapper_class: 'datepicker')
+      fae_input f, attribute, options
+    end
+
+    def fae_color_picker(f, attribute, options={})
+      options.update(
+        as: :string,
+        input_class: "js-color-picker color-picker #{'alpha-slider' unless options[:alpha] == false}",
+        input_html: { value: f.object.send(attribute).to_s } # value needs to be set to clear color picker
+      )
+      fae_input f, attribute, options
+    end
+
+    def fae_daterange(f, attr_array, options={})
+      raise "Fae::MissingRequiredOption: fae_daterange requires the 'label' option." if options[:label].blank?
+      raise "Fae::MalformedArgument: fae_daterange requires an array of two attributes as it's second argument." unless attr_array.present? && attr_array.is_a?(Array) && attr_array.length == 2
+      options.update(as: :date_range, start_date: attr_array.first, end_date: attr_array.second)
+      fae_input f, options[:label], options
+    end
+
+    def fae_grouped_select(f, attribute, options={})
+      raise "Fae::MissingRequiredOption: fae_grouped_select requires a `collection` option or `groups` and `labels` options." if !options.has_key?(:collection) && !options.has_key?(:groups) && !options.has_key?(:labels)
+      raise "Fae::MissingRequiredOption: fae_grouped_select required a `labels` option with a value containing an array when using the `groups` option." if options[:groups].present? && options[:labels].blank?
+      raise "Fae::MissingRequiredOption: fae_grouped_select required a `groups` option with a value containing an array when using the `labels` option." if options[:labels].present? && options[:groups].blank?
+
+      options[:collection] ||= group_options_for_collection(options[:labels], options[:groups])
+      options.update(as: :grouped_select, group_method: :last, wrapper_class: "#{options[:wrapper_class]} select")
+      association_or_input f, attribute, options
+    end
+
+    def fae_video_url(f, attribute, options={})
+      options[:helper_text] ||= "Please enter your YouTube video ID. The video ID is between v= and & of the video's url. This is typically 11 characters long."
+      options[:hint] ||= '<div class="youtube-hint"></div>'
+      fae_input f, attribute, options
+    end
+
+
+    private
+
+    def custom_options(attribute, options)
+      add_input_class(options, options[:input_class]) if options[:input_class].present?
+      add_input_class(options, 'slug') if attribute == :slug
+      options.update(wrapper_class: "#{options[:wrapper_class]} input") if options[:wrapper_class].present?
+      options.update(validate: true) unless options[:validate].present? && options[:validate] == false
+    end
+
+    def label_and_hint(attribute, options)
+      hint = options[:hint]
+
+      options[:helper_text] = attempt_common_helper_text(attribute) if options[:helper_text].blank?
+
+      attribute_name = options[:as].to_s == 'hidden' ? '' : attribute.to_s.titleize
+      label = options[:label] || attribute_name
+      if options[:markdown_supported].present? || options[:helper_text].present?
+        label += content_tag :h6, class: 'helper_text' do
+          concat(options[:helper_text]) if options[:helper_text].present?
+          concat(content_tag(:span, 'Markdown Supported', class: 'markdown-support')) if options[:markdown_supported].present?
+        end
+      end
+      options[:label] = label.html_safe if label.present?
+
+      options[:hint] = hint.html_safe if hint.present?
+    end
+
+    def is_attribute_or_association?(f, attribute)
+      f.object.has_attribute?(attribute) || is_association?(f, attribute)
+    end
+
+    def is_association?(f, attribute)
+      f.object.class.reflections.include?(attribute) || f.object.class.reflections.include?(attribute.to_s)
+    end
+
+    def association_or_input(f, attribute, options)
+      if is_attribute_or_association?(f, attribute)
+        f.object.attribute_names.include?(attribute.to_s) ? fae_input(f, attribute, options) : fae_association(f, attribute, options)
+      else
+        raise "Fae::undefined method '#{attribute}' for #{f.object}"
+      end
+    end
+
+    def symbol(type, val, options)
+      options[:as] = :symbol
+      options[:wrapper_class] = options[:wrapper_class].present? ? "#{options[:wrapper_class]} input symbol--#{type}" : "input symbol--#{type}"
+      options[:span_class]  = "input-symbol--#{type}"
+      options[:span_class] += " icon-#{val}" if options[:icon].present?
+      options[:content_text] = val if options[:icon].blank?
+    end
+
+    def group_options_for_collection(labels, groups)
+      raise "Fae::groups and labels must be an array" if !(labels.is_a? Array) || !(groups.is_a? Array)
+      raise "Fae::grouped options must be arrays of equal length. label length: #{labels.length}, options_length: #{groups.length}" if labels.length != groups.length
+
+      collection = {}
+      labels.each_with_index { |label, i| collection[label] = groups[i] }
+      collection
+    end
+
+    def to_class(attribute)
+      attribute.to_s.classify.constantize
+    end
+
+    def add_input_class(options, class_name)
+      if options.key?(:input_html)
+        options[:input_html].merge!({class: "#{options[:input_html][:class]} #{class_name}"})
+      else
+        options[:input_html] = { class: class_name }
+      end
+    end
+
+    # sets collection to class.for_fae_index if not defined
+    def list_order(f, attribute, options)
+      if is_association?(f, attribute) && !options[:collection]
+        begin
+          options[:collection] = to_class(attribute).for_fae_index
+        rescue NameError
+          raise "Fae::MissingCollection: `#{attribute}` isn't an orderable class, define your order using the `collection` option."
+        end
+      end
+    end
+
+    # sets default prompt for pulldowns
+    def set_prompt(f, attribute, options)
+      options[:prompt] = 'Select One' if is_association?(f, attribute) && f.object.class.reflect_on_association(attribute).macro == :belongs_to && options[:prompt].nil? && !options[:two_pane]
+    end
+
+    # removes language suffix from label and adds data attr for languange nav
+    def language_support(f, attribute, options)
+      return if Fae.languages.blank?
+
+      attribute_array = attribute.to_s.split('_')
+      language_suffix = attribute_array.pop
+      return unless Fae.languages.has_key?(language_suffix.to_sym) || Fae.languages.has_key?(language_suffix)
+
+      label = attribute_array.push("(#{language_suffix})").join(' ').titleize
+      options[:label] = label unless options[:label].present?
+
+      if options[:wrapper_html].present?
+        options[:wrapper_html].deep_merge!({ data: { language: language_suffix } })
+      else
+        options[:wrapper_html] = { data: { language: language_suffix } }
+      end
+    end
+
+    def set_maxlength(f, attribute, options)
+      column = f.object.class.columns_hash[attribute.to_s]
+      if column.present? && (column.sql_type.include?('varchar') || column.sql_type == 'text')
+        # Rails 4.1 supports column.limit, 4.2 supports column.cast_type.limit
+        limit = column.try(:limit) || column.try(:cast_type).try(:limit)
+        if limit.present?
+          options[:input_html] ||= {}
+          options[:input_html][:maxlength] ||= limit
+        end
+      end
+    end
+
+    def attempt_common_helper_text(attribute)
+      case attribute
+      when :seo_title
+       return 'A descriptive page title of ~50-65 characters. Displayed in search engine results.'
+      when :seo_description
+       return 'A helpful page summary of 320 characters or less. Displayed in search engine results.'
+      else
+       ''
+      end
+    end
+
+  end
+end

data/app/helpers/fae/nested_form_helper.rb

@@ -0,0 +1,39 @@
+module Fae
+  module NestedFormHelper
+
+    def th_columns(attribute)
+      if (attribute.is_a?(Hash) && attribute[:title])
+        attribute = attribute[:title]
+        attribute_title = attribute
+      else
+        attribute = :modified if ['updated_at', 'modified_at'].include? attribute.to_s
+        attribute_title = attribute.to_s.titleize
+      end
+
+      th_class = '-action-wide' if [:on_production, :on_prod, :on_stage, :updated_at, :created_at, :modified].include?(attribute)
+      content_tag(:th, class: th_class) do attribute_title end
+    end
+
+    def td_columns(params)
+      attribute = params[:col]
+      attributes = params[:cols]
+      item = params[:item]
+
+      attribute = (attribute.is_a?(Hash) && attribute[:attr]) ? attribute[:attr] : attribute
+      first_attribute = (attributes.first.kind_of?(Hash) && attributes.first[:attr]) ? attributes.first[:attr] : attributes.first
+
+      if attribute == first_attribute && !params[:edit_column]
+        content_tag(:td) do
+          content_tag(:a, class: 'js-edit-link', href: self.send(params[:edit_path], item)) do
+            col_name_or_image(item, attribute)
+          end
+        end
+      elsif item.class.columns_hash[attribute.to_s].present? && item.class.columns_hash[attribute.to_s].type == :boolean
+        content_tag(:td, fae_toggle(item, attribute))
+      else
+        content_tag(:td, col_name_or_image(item, attribute))
+      end
+    end
+
+  end
+end

data/app/helpers/fae/view_helper.rb

@@ -0,0 +1,175 @@
+module Fae
+  module  ViewHelper
+
+    def fae_date_format(datetime, timezone = @option.time_zone)
+      datetime.in_time_zone(timezone).strftime('%m/%d/%y') if is_date_or_time?(datetime)
+    end
+
+    def fae_datetime_format(datetime, timezone = @option.time_zone)
+      datetime.in_time_zone(timezone).strftime("%b %-d, %Y %l:%M%P %Z") if is_date_or_time?(datetime)
+    end
+
+    def fae_path
+      Rails.application.routes.url_helpers.fae_path[1..-1]
+    end
+
+    def fae_image_form(f, image_name, label: nil, alt_label: nil, caption_label: nil, show_alt: nil, show_caption: nil, required: nil, helper_text: nil, alt_helper_text: nil, caption_helper_text: nil, attached_as: nil)
+      render 'fae/images/image_uploader', f: f, image_name: image_name, label: label, alt_label: alt_label, caption_label: caption_label, show_alt: show_alt, show_caption: show_caption, required: required, helper_text: helper_text, alt_helper_text: alt_helper_text, caption_helper_text: caption_helper_text, attached_as: attached_as
+    end
+
+    def fae_file_form(f, file_name, label: nil, helper_text: nil, required: nil)
+      render 'fae/application/file_uploader', f: f, file_name: file_name, label: label, required: required, helper_text: helper_text
+    end
+
+    def fae_content_form(f, attribute, label: nil, hint: nil, helper_text: nil, markdown: nil, markdown_supported: nil, input_options: nil)
+      render 'fae/application/content_form', f: f, attribute: attribute, label: label, hint: hint, helper_text: helper_text, markdown: markdown, markdown_supported: markdown_supported, input_options: input_options
+    end
+
+    def fae_index_image(image, path = nil)
+      return if image.blank? || image.asset.blank? || image.asset.thumb.blank?
+      content_tag :div, class: 'image-mat' do
+        link_to_if path.present?, image_tag(image.asset.thumb.url), path
+      end
+    end
+
+    def fae_toggle(item, column)
+      active = item.send(column)
+      link_class = active ? 'slider-yes-selected' : ''
+      model_name = item.class.to_s.gsub('::','__').underscore.pluralize
+      url = fae.toggle_path(model_name, item.id.to_s, column)
+
+      link_to url, class: "slider-wrapper #{link_class}", method: :post, remote: true do
+        '<div class="slider-options">
+          <div class="slider-option slider-option-yes">Yes</div>
+          <div class="slider-option-selector"></div>
+          <div class="slider-option slider-option-no">No</div>
+        </div>'.html_safe
+      end
+    end
+
+    def fae_clone_button(item)
+      return if item.blank?
+      link_to "#{@index_path}?from_existing=#{item.id}", method: :post, title: 'Clone', class: 'js-tooltip table-action', data: { confirm: t('fae.clone_confirmation') } do
+        concat content_tag :i, nil, class: 'icon-copy'
+      end
+    end
+
+    def fae_delete_button(item, delete_path = nil, *custom_attrs)
+      return if item.blank?
+      delete_path ||= polymorphic_path([main_app, fae_scope, item.try(:fae_parent), item])
+      attrs = { method: :delete, title: 'Delete', class: 'js-tooltip table-action', data: { confirm: t('fae.delete_confirmation') } }
+      attrs.deep_merge!(custom_attrs[0]) if custom_attrs.present?
+      link_to delete_path, attrs do
+        concat content_tag :i, nil, class: 'icon-trash'
+      end
+    end
+
+    def fae_sort_id(item)
+      return if item.blank?
+      klass = item.class.name.underscore.gsub('/','__')
+      "#{klass}_#{item.id}"
+    end
+
+    def fae_filter_form(options = {}, &block)
+      options[:collection] ||= @items
+      options[:action]     ||= "#{@index_path}/filter"
+      options[:title]      ||= "Search #{@klass_humanized.pluralize.titleize}"
+      options[:search]       = true if options[:search].nil?
+      options[:cookie_key] ||= false
+
+      return if options[:collection].blank?
+
+      form_hash = { class: 'js-filter-form table-filter-area' }
+      form_hash['data-cookie-key'] = options[:cookie_key] if options[:cookie_key].present?
+
+      filter_header = content_tag(:div, class: 'table-filter-header') do
+        concat content_tag :h4, options[:title]
+        concat filter_search_field if options[:search]
+      end
+
+      form_tag(options[:action], form_hash) do
+        concat filter_header
+
+        if block_given?
+          filter_group_wrapper = content_tag(:div, class: 'table-filter-group-wrapper') do
+            concat capture(&block)
+            concat content_tag(:div, content_tag(:a, 'Reset Search', class: 'js-reset-btn button -small hidden', href: '#'), class: 'table-filter-group')
+          end
+        end
+
+        concat filter_group_wrapper
+        # I know this `unless !` looks like it should be an `if` but it's definitely supposed to be `unless !`
+        concat submit_tag 'Apply Filters', class: 'hidden' unless !options[:search]
+      end
+    end
+
+    def fae_filter_select(attribute, options = {})
+      options[:label]           ||= attribute.to_s.titleize
+      options[:collection]      ||= default_collection_from_attribute(attribute)
+      options[:label_method]    ||= :fae_display_field
+      options[:placeholder]       = "All #{options[:label].pluralize}" if options[:placeholder].nil?
+      options[:options]         ||= []
+      options[:grouped_by]      ||= nil
+      options[:grouped_options] ||= []
+
+      # grouped_by takes priority over grouped_options
+      if options[:grouped_by].present?
+        select_options = filter_generate_select_group(options[:collection], options[:grouped_by], options[:label_method])
+      elsif options[:grouped_options].present?
+        select_options = grouped_options_for_select(options[:grouped_options])
+      else
+        select_options = options_from_collection_for_select(options[:collection], 'id', options[:label_method])
+        select_options = options_for_select(options[:options]) if options[:options].present?
+      end
+
+
+      content_tag :div, class: 'table-filter-group' do
+        concat label_tag "filter[#{attribute}]", options[:label]
+        concat select_tag "filter[#{attribute}]", select_options, prompt: options[:placeholder]
+      end
+    end
+
+    def fae_avatar(user = current_user)
+      hash = Digest::MD5.hexdigest(user.email.downcase)
+      "https://secure.gravatar.com/avatar/#{hash}?s=80&d=mm"
+    end
+
+    def fae_paginate(items)
+      content_tag :nav, class: 'pagination', data: { filter_path: "#{@index_path}/filter" } do
+        paginate items, theme: 'fae'
+      end
+    end
+
+    private
+
+    def filter_search_field
+      content_tag :div, class: 'table-filter-keyword-wrapper' do
+        concat text_field_tag 'filter[search]', nil, placeholder: 'Search by Keyword'
+        concat content_tag(:i, '', class: 'icon-search')
+      end
+    end
+
+    def filter_generate_select_group(collection, grouped_by, label_method)
+      labels = collection.map { |c| c.send(grouped_by).try(:fae_display_field) }.uniq
+      grouped_hash = {}
+
+      labels.each do |label|
+        values = collection.select { |c| c.send(grouped_by).try(:fae_display_field) == label }
+        grouped_hash[label] = values.map { |v| [v.send(label_method), v.id] }
+      end
+
+      grouped_options_for_select(grouped_hash)
+    end
+
+    def default_collection_from_attribute(attribute)
+      attribute.to_s.classify.constantize.for_fae_index
+    rescue NameError
+      []
+    end
+
+    def is_date_or_time?(datetime)
+      datetime.present? && ( datetime.kind_of?(Date) || datetime.kind_of?(Time) || datetime.kind_of?(ActiveSupport::TimeWithZone) )
+    end
+
+  end
+end