releaf-core 0.2.1 → 1.0.3

data/app/builders/releaf/builders/form_builder/associations.rb

@@ -0,0 +1,153 @@
+module Releaf::Builders::FormBuilder::Associations
+  def relation_name(name)
+    name.to_s.sub(/_id$/, '').to_sym
+  end
+
+  def association_reflector(reflection, fields)
+    fields ||= resource_fields.association_attributes(reflection)
+    Releaf::Builders::AssociationReflector.new(reflection, fields, sortable_column_name)
+  end
+
+  def reflect_on_association(association_name)
+    object.class.reflect_on_association(association_name)
+  end
+
+  def releaf_association_fields(reflection, fields)
+    reflector = association_reflector(reflection, fields)
+
+    case reflector.macro
+    when :has_many
+      releaf_has_many_association(reflector)
+    when :belongs_to
+      releaf_belongs_to_association(reflector)
+    when :has_one
+      releaf_has_one_association(reflector)
+    else
+      raise 'not implemented'
+    end
+  end
+
+  def releaf_belongs_to_association(reflector)
+    releaf_has_one_or_belongs_to_association(reflector)
+  end
+
+  def releaf_has_one_association(reflector)
+    object.send("build_#{reflector.name}") unless object.send(reflector.name).present?
+    releaf_has_one_or_belongs_to_association(reflector)
+  end
+
+  def releaf_has_one_or_belongs_to_association(reflector)
+    tag(:fieldset, class: "type-association", data: {name: reflector.name}) do
+      tag(:legend, translate_attribute(reflector.name)) <<
+      fields_for(reflector.name, object.send(reflector.name), relation_name: reflector.name, builder: self.class) do |builder|
+        builder.releaf_fields(reflector.fields)
+      end
+    end
+  end
+
+  def releaf_has_many_association(reflector)
+    item_template = releaf_has_many_association_fields(reflector, reflector.klass.new, '_template_', true)
+
+    tag(:section, class: "nested", data: {name: reflector.name, "releaf-template" => html_escape(item_template.to_str)}) do
+      [
+        releaf_has_many_association_header(reflector),
+        releaf_has_many_association_body(reflector),
+        releaf_has_many_association_footer(reflector)
+      ]
+    end
+  end
+
+  def releaf_has_many_association_header(reflector)
+    tag(:header) do
+      tag(:h1, translate_attribute(reflector.name))
+    end
+  end
+
+  def releaf_has_many_association_body(reflector)
+    attributes = {
+      class: ["body", "list"]
+    }
+    attributes["data"] = {sortable: nil} if reflector.sortable?
+
+    tag(:div, attributes) do
+      association_collection(reflector).each_with_index.map do |association_object, index|
+        releaf_has_many_association_fields(reflector, association_object, index, reflector.destroyable?)
+      end
+    end
+  end
+
+  def releaf_has_many_association_footer(_reflector)
+    tag(:footer){ field_type_add_nested }
+  end
+
+  def releaf_has_many_association_fields(reflector, association_object, association_index, destroyable)
+    tag(:fieldset, class: ["item", "type-association"], data: {name: reflector.name, index: association_index}) do
+      fields_for(reflector.name, association_object, relation_name: reflector.name,
+                 child_index: association_index, builder: self.class) do |builder|
+        builder.releaf_has_many_association_field(reflector, destroyable)
+      end
+    end
+  end
+
+  def releaf_has_many_association_field(reflector, destroyable)
+    content = ActiveSupport::SafeBuffer.new
+    skippable_fields = []
+
+    if reflector.sortable?
+      skippable_fields << sortable_column_name
+      content << hidden_field(sortable_column_name.to_sym, class: "item-position")
+      content << tag(:div, "&nbsp;".html_safe, class: "handle")
+    end
+
+    content << releaf_fields(reflector.fields - skippable_fields)
+    content << field_type_remove_nested if destroyable
+
+    content
+  end
+
+  def releaf_item_field_choices(name, options = {})
+    if options.key? :select_options
+      options[:select_options]
+    else
+      releaf_item_field_collection(name, options).collect{|item| [resource_title(item), item.id]}
+    end
+  end
+
+  def releaf_item_field_collection(name, options = {})
+    options[:collection] || object.class.reflect_on_association(relation_name(name)).try(:klass).try(:all)
+  end
+
+  def releaf_item_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    label_options = {translation_key: name.to_s.sub(/_id$/, '').to_s}
+    attributes = input_attributes(name, {value: object.send(name)}.merge(input), options)
+    options = {field: {type: "item"}, label: label_options}.deep_merge(options)
+
+
+    # add empty value when validation exists, so user is forced to choose something
+    unless options.key? :include_blank
+      options[:include_blank] = true
+      object.class.validators_on(name).each do |validator|
+        next unless validator.is_a? ActiveModel::Validations::PresenceValidator
+        # if new record, or object is missing (was deleted)
+        options[:include_blank] = object.new_record? || object.send(relation_name(name)).blank?
+        break
+      end
+    end
+
+
+    choices = releaf_item_field_choices(name, options)
+    content = select(name, choices, options, attributes)
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  def field_type_remove_nested
+    button_attributes = {title: t('Remove'), class: "danger remove-nested-item"}
+    wrapper(class: "remove-item-box") do
+      button(nil, "trash-o", button_attributes) << hidden_field("_destroy", class: "destroy")
+    end
+  end
+
+  def field_type_add_nested
+    button(t('Add item'), "plus", class: "primary add-nested-item")
+  end
+end

data/app/builders/releaf/builders/form_builder/boolean_fields.rb

@@ -0,0 +1,12 @@
+module Releaf::Builders::FormBuilder::BooleanFields
+  def releaf_boolean_field(name, input: {}, label: {}, field: {}, options: {})
+    attributes = input_attributes(name, input, options)
+    options = {field: {type: "boolean"}}.deep_merge(options)
+
+    wrapper(field_attributes(name, field, options)) do
+      wrapper(class: "value") do
+        check_box(name, attributes) << releaf_label(name, label, options.deep_merge(label: {minimal: true}))
+      end
+    end
+  end
+end

data/app/builders/releaf/builders/form_builder/date_fields.rb

@@ -0,0 +1,30 @@
+module Releaf::Builders::FormBuilder::DateFields
+  def date_or_time_field(name, type, input: {}, label: {}, field: {}, options: {})
+    input = date_or_time_field_input_attributes(name, type, input)
+    options = {field: {type: type.to_s}}.deep_merge(options)
+    releaf_text_field(name, input: input, label: label, field: field, options: options)
+  end
+
+  def date_or_time_field_input_attributes(name, type, attributes)
+    {
+      class: "text #{type}-picker",
+      value: Releaf::Builders::Utilities::DateFields.format_date_or_time_value(object.send(name), type),
+      data: {
+        "date-format" => Releaf::Builders::Utilities::DateFields.date_format_for_jquery,
+        "time-format" => Releaf::Builders::Utilities::DateFields.time_format_for_jquery
+      }
+    }.deep_merge(attributes)
+  end
+
+  def releaf_datetime_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_field(name, :datetime, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_time_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_field(name, :time, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_date_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_field(name, :date, input: input, label: label, field: field, options: options)
+  end
+end

data/app/builders/releaf/builders/form_builder/fields.rb

@@ -0,0 +1,10 @@
+module Releaf::Builders::FormBuilder::Fields
+  include Releaf::Builders::FormBuilder::TextFields
+  include Releaf::Builders::FormBuilder::AssociatedSetField
+  include Releaf::Builders::FormBuilder::DateFields
+  include Releaf::Builders::FormBuilder::I18nFields
+  include Releaf::Builders::FormBuilder::RichtextFields
+  include Releaf::Builders::FormBuilder::NumberFields
+  include Releaf::Builders::FormBuilder::FileFields
+  include Releaf::Builders::FormBuilder::BooleanFields
+end

data/app/builders/releaf/builders/form_builder/file_fields.rb

@@ -0,0 +1,47 @@
+module Releaf::Builders::FormBuilder::FileFields
+  def releaf_image_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    name = name.to_s.sub(/_uid$/, '')
+
+    attributes = {
+      accept: 'image/png,image/jpeg,image/bmp,image/gif'
+    }.merge(input)
+
+    attributes = input_attributes(name, attributes, options)
+
+    options = {field: {type: "image"}}.deep_merge(options)
+    content = file_field(name, attributes)
+    if object.send(name).present?
+      content += tag(:div, class: "value-preview") do
+        inner_content = tag(:div, class: "image-wrap") do
+          thumbnail = image_tag(object.send(name).thumb('410x128>').url, alt: '')
+          hidden_field("retained_#{name}") +
+            link_to(thumbnail, object.send(name).url, target: :_blank, class: :ajaxbox, rel: :image)
+        end
+        inner_content << releaf_file_remove_button(name)
+      end
+    end
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  def releaf_file_remove_button(name)
+    tag(:div, class: "remove") do
+      check_box("remove_#{name}") << label("remove_#{name}", t("Remove"))
+    end
+  end
+
+  def releaf_file_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    name = name.to_s.sub(/_uid$/, '')
+    attributes = input_attributes(name, input, options)
+    options = {field: {type: "file"}}.deep_merge(options)
+
+    content = file_field(name, attributes)
+    if object.send(name).present?
+      content << hidden_field("retained_#{name}")
+      content << link_to(t("Download"), object.send(name).url, target: "_blank")
+      content << releaf_file_remove_button(name)
+    end
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+end

data/app/builders/releaf/builders/form_builder/i18n_fields.rb

@@ -0,0 +1,75 @@
+module Releaf::Builders::FormBuilder::I18nFields
+  def releaf_text_i18n_field(name, input: {}, label: {}, field: {}, options: {})
+    options = {field: {type: "text"}}.deep_merge(options)
+    input = {class: "text"}.deep_merge(input)
+    localized_field(name, :text_field, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_link_i18n_field(name, input: {}, label: {}, field: {}, options: {})
+    options = {field: {type: "link"}}.deep_merge(options)
+    releaf_text_i18n_field(name, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_textarea_i18n_field(name, input: {}, label: {}, field: {}, options: {})
+    input = {
+      rows: 5,
+      cols: 75,
+    }.merge(input)
+    options = {field: {type: "textarea"}}.deep_merge(options)
+    localized_field(name, :text_area, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_richtext_i18n_field(name, input: {}, label: {}, field: {}, options: {})
+    input = richtext_input_attributes(name).merge(input)
+    options = richtext_options(name, options)
+    releaf_textarea_i18n_field(name, input: input, label: label, field: field, options: options)
+  end
+
+  def localized_field(name, field_type, input: {}, label: {}, field: {}, options: {})
+    options = {i18n: true, label: {translation_key: name}}.deep_merge(options)
+
+    wrapper(field_attributes(name, field, options)) do
+      content = object.class.globalize_locales.collect do |locale|
+        localized_name = "#{name}_#{locale}"
+        html_class = ["localization"]
+        html_class << "active" if locale == default_locale
+
+        tag(:div, class: html_class, data: {locale: locale}) do
+          releaf_label(localized_name, label, options) <<
+          tag(:div, class: "value") do
+            attributes = input_attributes(name, {value: object.send(localized_name)}.merge(input), options)
+            send(field_type, localized_name, attributes)
+          end
+        end
+      end
+
+      content << localization_switch
+    end
+  end
+
+  def localization_switch
+    tag(:div, class: "localization-switch") do
+      button_tag(type: 'button', title: t('Switch locale'), class: "trigger") do
+        tag(:span, default_locale, class: "label") + tag(:i, nil, class: ["fa", "fa-chevron-down"])
+      end <<
+      tag(:menu, class: ["localization-menu-items"], type: 'toolbar') do
+        tag(:ul) do
+          object.class.globalize_locales.collect do |locale|
+            tag(:li) do
+              tag(:button, translate_locale(locale), type: "button", data: {locale: locale})
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def locales
+    object.class.globalize_locales
+  end
+
+  def default_locale
+    selected_locale = (layout_settings("releaf.i18n.locale") || I18n.locale).to_sym
+    locales.include?(selected_locale) ? selected_locale : locales.first
+  end
+end

data/app/builders/releaf/builders/form_builder/label.rb

@@ -0,0 +1,34 @@
+module Releaf::Builders::FormBuilder::Label
+  def releaf_label(name, attributes, options = {})
+    label_options = options.fetch(:label, {})
+    attributes = label_attributes(name, attributes, options)
+    text = label_text(name, label_options)
+
+    content = label(name, text, attributes)
+
+    if label_options.fetch(:minimal, false) == true
+      content
+    else
+      content += wrapper(label_options[:description], class: "description") if label_options.fetch(:description, nil).present?
+      wrapper(content, class: "label-wrap")
+    end
+  end
+
+  def label_text(name, options = {})
+    if options[:label_text].present?
+      options[:label_text]
+    else
+      if options[:translation_key].present?
+        key = options[:translation_key]
+      else
+        key = name.to_s.sub(/_uid$/, '')
+      end
+
+      translate_attribute(key)
+    end
+  end
+
+  def label_attributes(_name, attributes, _options)
+    attributes
+  end
+end

data/app/builders/releaf/builders/form_builder/number_fields.rb

@@ -0,0 +1,13 @@
+module Releaf::Builders::FormBuilder::NumberFields
+  def releaf_number_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    attributes = input_attributes(name, {value: object.send(name), step: "any", class: "text" }.merge(input), options)
+    options = {field: {type: "number"}}.deep_merge(options)
+    content = number_field(name, attributes)
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  alias_method :releaf_integer_field, :releaf_number_field
+  alias_method :releaf_float_field, :releaf_number_field
+  alias_method :releaf_decimal_field, :releaf_number_field
+end

data/app/builders/releaf/builders/form_builder/richtext_fields.rb

@@ -0,0 +1,28 @@
+module Releaf::Builders::FormBuilder::RichtextFields
+  def releaf_richtext_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    attributes = richtext_input_attributes(name)
+      .merge(value: object.send(name))
+      .merge(input)
+    attributes = input_attributes(name, attributes, options)
+
+    options = richtext_options(name, options)
+    content = text_area(name, attributes)
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  def richtext_input_attributes(_name)
+    {
+      rows: 5,
+      cols: 50,
+      class: "richtext",
+      data: {
+        "attachment-upload-url" => (controller.respond_to?(:releaf_richtext_attachment_upload_url) ? controller.releaf_richtext_attachment_upload_url : '')
+      },
+    }
+  end
+
+  def richtext_options(name, options)
+    {field: {type: "richtext"}, label: {translation_key: name.to_s.sub(/_html$/, '').to_s }}.deep_merge(options)
+  end
+end

data/app/builders/releaf/builders/form_builder/text_fields.rb

@@ -0,0 +1,43 @@
+module Releaf::Builders::FormBuilder::TextFields
+  def releaf_textarea_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    attributes = {
+      rows: 5,
+      cols: 75,
+      value: object.send(name)
+    }.merge(input)
+
+    attributes = input_attributes(name, attributes, options)
+
+    options = {field: {type: "textarea"}}.deep_merge(options)
+    content = text_area(name, attributes)
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  def releaf_email_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    options = {field: {type: "email"}}.deep_merge(options)
+    input = {type: "email"}.deep_merge(input)
+    releaf_text_field(name, input: input, label: label, field: field, options: options, &block)
+  end
+
+  def releaf_link_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    options = {field: {type: "link"}}.deep_merge(options)
+    releaf_text_field(name, input: input, label: label, field: field, options: options, &block)
+  end
+
+  def releaf_password_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    attributes = input_attributes(name, {autocomplete: "off", class: "text"}.merge(input), options)
+    options = {field: {type: "password"}}.deep_merge(options)
+    content = password_field(name, attributes)
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+
+  def releaf_text_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    attributes = input_attributes(name, {value: object.send(name), class: "text"}.merge(input), options)
+    options = {field: {type: "text"}}.deep_merge(options)
+    content = text_field(name, attributes)
+
+    input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
+  end
+end