releaf-core 0.2.1

data/app/assets/stylesheets/releaf/vendor/magnific-popup/settings.scss

@@ -0,0 +1,45 @@
+////////////////////////
+//      Settings      //
+////////////////////////
+
+// overlay
+$mfp-overlay-color:                   #0b0b0b !default;                    // Color of overlay screen
+$mfp-overlay-opacity:                 0.8 !default;                        // Opacity of overlay screen
+$mfp-shadow:                          0 0 8px rgba(0, 0, 0, 0.6) !default; // Shadow on image or iframe
+
+// spacing
+$mfp-popup-padding-left:              8px!default ;                        // Padding from left and from right side
+$mfp-popup-padding-left-mobile:       6px !default;                        // Same as above, but is applied when width of window is less than 800px
+
+$mfp-z-index-base:                    1040 !default;                       // Base z-index of popup
+
+// controls
+$mfp-include-arrows:                  true !default;                       // Include styles for nav arrows
+$mfp-controls-opacity:                0.65 !default;                       // Opacity of controls
+$mfp-controls-color:                  #FFF !default;                       // Color of controls
+$mfp-controls-border-color:           #3F3F3F !default;                      // Border color of controls
+$mfp-inner-close-icon-color:          #333 !default;                       // Color of close button when inside
+$mfp-controls-text-color:             #CCC !default;                       // Color of preloader and "1 of X" indicator
+$mfp-controls-text-color-hover:       #FFF !default;                       // Hover color of preloader and "1 of X" indicator
+$mfp-IE7support:                      true !default;                       // Very basic IE7 support
+
+// Iframe-type options
+$mfp-include-iframe-type:             true !default;                       // Enable Iframe-type popups
+$mfp-iframe-padding-top:              40px !default;                       // Iframe padding top
+$mfp-iframe-background:               #000 !default;                       // Background color of iframes
+$mfp-iframe-max-width:                900px !default;                      // Maximum width of iframes
+$mfp-iframe-ratio:                    9/16 !default;                       // Ratio of iframe (9/16 = widescreen, 3/4 = standard, etc.)
+
+// Image-type options
+$mfp-include-image-type:              true !default;                       // Enable Image-type popups
+$mfp-image-background:                #444 !default;
+$mfp-image-padding-top:               40px !default;                       // Image padding top
+$mfp-image-padding-bottom:            40px !default;                       // Image padding bottom
+$mfp-include-mobile-layout-for-image: true !default;                       // Removes paddings from top and bottom
+
+// Image caption options
+$mfp-caption-title-color:             #F3F3F3 !default;                    // Caption title color
+$mfp-caption-subtitle-color:          #BDBDBD !default;                    // Caption subtitle color
+
+// A11y
+$mfp-use-visuallyhidden:              false !default;                      // Hide content from browsers, but make it available for screen readers

data/app/builders/releaf/builders/association_reflector.rb

@@ -0,0 +1,58 @@
+class Releaf::Builders::AssociationReflector
+  delegate :macro, :name, :klass, to: :reflection
+
+  attr_accessor :reflection, :fields, :sortable_column_name, :sortable_cache
+
+  def initialize(reflection, fields, sortable_column_name)
+    self.reflection = reflection
+    self.fields = fields
+    self.sortable_column_name = sortable_column_name.to_sym
+  end
+
+  def sortable?
+    if @sortable.nil?
+      @sortable = (expected_order_clause == actual_order_clause)
+    end
+
+    @sortable
+  end
+
+  def destroyable?
+    if @destroyable.nil?
+      @destroyable = reflection
+        .active_record
+        .nested_attributes_options
+        .fetch(reflection.name, {})
+        .fetch(:allow_destroy, false)
+    end
+
+    @destroyable
+  end
+
+  def actual_order_clause
+    relation = reflection.klass.all
+
+    if reflection.scope
+      relation = relation.instance_exec(reflection.active_record, &reflection.scope)
+    end
+
+    extract_order_clause(relation)
+  end
+
+  def expected_order_clause
+    relation = reflection.klass.all.order(sortable_column_name)
+    extract_order_clause(relation)
+  end
+
+  def extract_order_clause(relation)
+    relation.order_values.map{|value| value_as_sql(value) }.join(", ")
+  end
+
+  def value_as_sql(value)
+    if value.respond_to?(:to_sql)
+      value.to_sql
+    else
+      value
+    end
+  end
+end

data/app/builders/releaf/builders/base.rb

@@ -0,0 +1,80 @@
+module Releaf::Builders::Base
+  extend ActiveSupport::Concern
+
+  delegate :controller, :controller_name, :url_for, :form_for,
+    :releaf_button, :params, :form_tag, :file_field_tag,
+    :request, :check_box_tag, :label_tag, :content_tag, :hidden_field_tag,
+    :render, :link_to, :flash, :truncate, :radio_button_tag,
+    :options_for_select, :action_name, :options_from_collection_for_select,
+    :select_tag, :text_field_tag,
+    :image_tag, :jquery_date_format, :cookies, :button_tag, :merge_attributes, to: :template
+
+  delegate :layout_settings, :access_control, :controller_scope_name,
+    :feature_available?, :index_url, to: :controller
+
+  alias_method :button, :releaf_button
+
+  def wrapper(content_or_attributes_with_block, attributes = {}, &block)
+    if block_given?
+      tag(:div, content_or_attributes_with_block, nil, nil, &block)
+    else
+      tag(:div, content_or_attributes_with_block, attributes)
+    end
+  end
+
+  def html_escape(value)
+    ERB::Util.html_escape(value)
+  end
+
+  def tag(*args, &block)
+    return content_tag(*args) unless block_given?
+
+    content_tag(*args) do
+      block_result = yield
+      if block_result.is_a? Array
+        safe_join do
+          block_result
+        end
+      else
+        block_result.to_s
+      end
+    end
+  end
+
+  def template_variable(variable)
+    template.instance_variable_get("@#{variable}")
+  end
+
+  def icon(name)
+    template.fa_icon(name)
+  end
+
+  def safe_join(&block)
+    template.safe_join(yield)
+  end
+
+  def t(key, options = {})
+    options[:scope] = default_translation_scope unless options.key? :scope
+    I18n.t(key, options)
+  end
+
+  def translate_locale(locale)
+    t(locale, scope: "locales")
+  end
+
+  def locale_options(locales)
+    locales.collect do|locale|
+      [translate_locale(locale), locale]
+    end
+  end
+
+  def default_translation_scope
+    controller_scope_name
+  end
+
+  # calls `#to_text` on resource if resource supports it. Otherwise calls
+  # `#to_s` method
+  def resource_to_text(resource)
+    resource.send(resource.respond_to?(:to_text) ? :to_text : :to_s)
+  end
+end

data/app/builders/releaf/builders/collection.rb

@@ -0,0 +1,8 @@
+module Releaf::Builders::Collection
+  attr_accessor :collection
+
+  def initialize(template)
+    super
+    self.collection = template_variable("collection")
+  end
+end

data/app/builders/releaf/builders/confirm_destroy_dialog_builder.rb

@@ -0,0 +1,25 @@
+class Releaf::Builders::ConfirmDestroyDialogBuilder < Releaf::Builders::ConfirmDialogBuilder
+  def question_content
+    t("Do you want to delete the following object?")
+  end
+
+  def description_content
+    resource_to_text(resource)
+  end
+
+  def section_header_text
+    t("Confirm deletion")
+  end
+
+  def confirm_method
+    :delete
+  end
+
+  def icon_name
+    "trash-o"
+  end
+
+  def confirm_url
+    url_for( action: 'destroy', id: resource.id, index_url: index_url)
+  end
+end

data/app/builders/releaf/builders/confirm_dialog_builder.rb

@@ -0,0 +1,54 @@
+class Releaf::Builders::ConfirmDialogBuilder
+  include Releaf::Builders::ResourceDialog
+
+  attr_accessor :form
+
+  def output
+    tag(:section, section_attributes) do
+      form_for(resource, confirm_form_options) do |form|
+        self.form = form
+        safe_join do
+          section_blocks
+        end
+      end
+    end
+  end
+
+  def section_body
+    tag(:div, class: "body") do
+      section_body_blocks
+    end
+  end
+
+  def section_body_blocks
+    [
+      icon(icon_name),
+      tag(:div, question_content, class: "question"),
+      tag(:div, description_content, class: "description")
+    ]
+  end
+
+  def section_attributes
+    merge_attributes(super, class: ["confirm"])
+  end
+
+  def footer_primary_tools
+    [cancel_button, confirm_button]
+  end
+
+  def confirm_form_options
+    {builder: Releaf::Builders::FormBuilder, url: confirm_url, as: :resource, method: confirm_method}
+  end
+
+  def confirm_button
+    button(t("Yes"), "check", class: "danger", type: 'submit')
+  end
+
+  def cancel_url
+    index_url
+  end
+
+  def cancel_button
+    button(t("No"), "ban", class: "secondary", data: {type: 'cancel'}, href: index_url)
+  end
+end

data/app/builders/releaf/builders/edit_builder.rb

@@ -0,0 +1,66 @@
+class Releaf::Builders::EditBuilder
+  include Releaf::Builders::ResourceView
+
+  attr_accessor :form
+
+  def section_content
+    form_for(resource, form_options) do |form|
+      self.form = form
+      safe_join do
+        [index_url_preserver] + section_blocks
+      end
+    end
+  end
+
+  def index_url_preserver
+    hidden_field_tag 'index_url', params[:index_url] if params[:index_url].present?
+  end
+
+  def section_body_blocks
+    [error_notices, form_fields]
+  end
+
+  def form_fields
+    form.releaf_fields(form.field_names.to_a)
+  end
+
+  def form_options
+    controller.form_options(action_name, resource, :resource)
+  end
+
+  def error_notices
+    return unless resource.errors.any?
+    tag(:div, class: "form-error-box") do
+      error_notices_header <<
+      tag(:ul) do
+        resource.errors.full_messages.collect do|message|
+          tag(:li, message, class: "error")
+        end
+      end
+    end
+  end
+
+  def error_notices_header
+    tag(:strong, "#{resource.errors.count} validation #{"error".pluralize(resource.errors.count)} occured:")
+  end
+
+  def footer_primary_tools
+    tools = []
+    tools << save_and_create_another_button if create_another_available?
+    tools << save_button
+    tools
+  end
+
+  def create_another_available?
+    resource.present? && resource.new_record? && controller.feature_available?(:create_another)
+  end
+
+  def save_and_create_another_button
+    button(t("Save and create another"), "plus", name: "after_save", value: "create_another", class: "secondary", data: { type: 'ok', disable: true }, type: "submit")
+  end
+
+  def save_button
+    button(t("Save"), "check", class: "primary", data: { type: 'ok', disable: true }, type: "submit")
+  end
+
+end

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

@@ -0,0 +1,594 @@
+class Releaf::Builders::FormBuilder < ActionView::Helpers::FormBuilder
+  include Releaf::Builders::Base
+  include Releaf::Tags::AssociatedSetField
+  include Releaf::Builders::Orderer
+  attr_accessor :template
+
+  def field_names
+    resource_fields.values
+  end
+
+  def resource_fields
+    Releaf::Core::ResourceFields.new(object.class)
+  end
+
+  def field_render_method_name(name)
+    parts = [name]
+
+    builder = self
+    until builder.options[:parent_builder].nil? do
+      parts << builder.options[:relation_name] if builder.options[:relation_name]
+      builder = builder.options[:parent_builder]
+    end
+
+    parts << "render"
+    parts.reverse.join("_")
+  end
+
+  def normalize_fields(fields)
+    fields.flatten.map do |item|
+      if item.is_a? Hash
+        item.each_pair.map do |(association, subfields)|
+          normalize_field(association, subfields)
+        end
+      else
+        normalize_field(item, nil)
+      end
+    end.flatten
+  end
+
+  def normalize_field(field, subfields)
+    {
+      render_method: field_render_method_name(field),
+      field: field,
+      subfields: subfields
+    }
+  end
+
+  def releaf_fields(*fields)
+    safe_join do
+      normalize_fields(fields).collect{|field_option| render_field_by_options(field_option) }
+    end
+  end
+
+  def render_field_by_options(options)
+    if respond_to? options[:render_method]
+      send(options[:render_method])
+    else
+      reflection = reflect_on_association(options[:field])
+
+      if reflection
+        releaf_association_fields(reflection, options[:subfields])
+      else
+        releaf_field(options[:field])
+      end
+    end
+  end
+
+  def reflect_on_association(association_name)
+    object.class.reflect_on_association(association_name)
+  end
+
+  def association_reflector(reflection, fields)
+    fields ||= resource_fields.association_attributes(reflection)
+    Releaf::Builders::AssociationReflector.new(reflection, fields, sortable_column_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 field_type_remove_nested
+    button_attributes = {title: t('Remove item'), 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
+
+  def field_type_method(name)
+    type = Releaf::Core::TemplateFieldTypeMapper.field_type_name(object, name)
+    localization = Releaf::Core::TemplateFieldTypeMapper.use_i18n?(object, name)
+
+    "releaf_#{type}_#{'i18n_' if localization}field"
+  end
+
+  def releaf_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    method_name = field_type_method(name)
+    send(method_name, name, input: input, label: label, field: field, options: options, &block)
+  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_choices(name, options = {})
+    unless options.key? :select_options
+      options[:select_options] = releaf_item_field_collection(name, options)
+        .collect{|item| [resource_to_text(item), item.id]}
+    end
+
+    if options[:select_options].is_a? Array
+      choices = options_for_select(options[:select_options], object.send(name))
+    else
+      choices = options[:select_options]
+    end
+
+    choices
+  end
+
+  def relation_name(name)
+    name.to_s.sub(/_id$/, '').to_sym
+  end
+
+  def releaf_item_field(name, input: {}, label: {}, field: {}, options: {}, &block)
+    label = {translation_key: name.to_s.sub(/_id$/, '').to_s}.deep_merge(label)
+    attributes = input_attributes(name, {value: object.send(name)}.merge(input), options)
+    options = {field: {type: "item"}}.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 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
+
+  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
+
+  def date_or_time_fields(name, type, input: {}, label: {}, field: {}, options: {})
+    input = date_or_time_fields_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_fields_input_attributes(name, type, attributes)
+    value = object.send(name)
+    {
+      class: "text #{type}-picker",
+      data: {
+        "date-format" => date_format_for_jquery,
+        "time-format" => time_format_for_jquery
+      },
+      value: (format_date_or_time_value(value, type) if value)
+    }.merge(attributes)
+  end
+
+  def normalize_date_or_time_value(value, type)
+    case type
+    when :date
+      value.to_date
+    when :datetime
+      value.to_datetime
+    when :time
+      value.to_time
+    end
+  end
+
+  def format_date_or_time_value(value, type)
+    default_format = date_or_time_default_format(type)
+    value = normalize_date_or_time_value(value, type)
+
+    if type == :time
+      value.strftime(default_format)
+    else
+      I18n.l(value, default: default_format)
+    end
+  end
+
+  def time_format_for_jquery
+    format = date_or_time_default_format(:time)
+    jquery_date_format(format)
+  end
+
+  def date_format_for_jquery
+    format = date_or_time_default_format(:date)
+    jquery_date_format(t("default", scope: "date.formats", default: format))
+  end
+
+  def date_or_time_default_format(type)
+    case type
+    when :date
+      "%Y-%m-%d"
+    when :datetime
+      "%Y-%m-%d %H:%M"
+    when :time
+      "%H:%M"
+    end
+  end
+
+  def releaf_datetime_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_fields(name, :datetime, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_time_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_fields(name, :time, input: input, label: label, field: field, options: options)
+  end
+
+  def releaf_date_field(name, input: {}, label: {}, field: {}, options: {})
+    date_or_time_fields(name, :date, input: input, label: label, field: field, options: options)
+  end
+
+  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 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_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
+
+  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
+
+  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)
+    input = {class: "text"}.deep_merge(input)
+    localized_field(name, :text_field, input: input, label: label, field: field, options: options)
+  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
+
+  def releaf_richtext_i18n_field(name, input: {}, label: {}, field: {}, options: {})
+    input = richtext_input_attributes(name).merge(input)
+    options = richtext_options(name, options)
+    localized_field(name, :text_area, 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 default_locale
+    selected_locale = (cookies[:'releaf.i18n.locale'] || I18n.locale).to_sym
+    locales.include?(selected_locale) ? selected_locale : locales.first
+  end
+
+  def locales
+    object.class.globalize_locales
+  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, i|
+            tag(:li) do
+              tag(:button, translate_locale(locale), type: "button", data: {locale: locale})
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def input_wrapper_with_label(name, input_content, label: {}, field: {}, options: {})
+    field(name, field, options) do
+      input_content = safe_join{[input_content, yield.to_s]} if block_given?
+      releaf_label(name, label, options) << wrapper(input_content, class: "value")
+    end
+  end
+
+  def field(name, attributes, options, &block)
+    tag(:div, field_attributes(name, attributes, options), nil, nil, &block)
+  end
+
+  def field_attributes(name, attributes, options)
+    type = options.fetch(:field, {}).fetch(:type, nil)
+
+    classes = ["field", "type-#{type}"]
+    classes << "i18n" if options.key? :i18n
+
+    merge_attributes({class: classes, data: {name: name}}, attributes)
+  end
+
+  def label_attributes(name, attributes, options)
+    attributes
+  end
+
+  def input_attributes(name, attributes, options)
+    attributes
+  end
+
+
+  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 translate_attribute(attribute)
+    object.class.human_attribute_name(attribute, create_default: false)
+  end
+
+  def association_collection(reflector)
+    object.send(reflector.name)
+  end
+
+  def sortable_column_name
+    'item_position'
+  end
+end