Module: CoreFormHelper

Defined in:
app/helpers/core_form_helper.rb

Overview

helpers for creating forms

Instance Method Summary collapse

Instance Method Details

#form_field_id(model, field, options = {}) ⇒ HTML

This method is abstract.

Return a consistent form field id

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • options (Hash) (defaults to: {})

Returns:

  • (HTML) 


159
160
161
162
163
164
 
# File 'app/helpers/core_form_helper.rb', line 159

def form_field_id(model, field, options = {})
  return options[:form_id] if options[:form_id].present?

  field = "#{field}_id" if model.class.reflect_on_association(field).present?
  [options[:form_id_prefix], options[:base_name], options[:array_name] || model.class.to_s.underscore, options[:index], field].compact.join('_')
end

#form_field_name(model, field, options = {}) ⇒ HTML

This method is abstract.

Return a consistent form field name

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • options (Hash) (defaults to: {})

Returns:

  • (HTML) 


133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'app/helpers/core_form_helper.rb', line 133

def form_field_name(model, field, options = {})
  return options[:form_name] if options[:form_name].present?

  # TODO: Need to handle the other side of the 1:M use case where
  # the field name needs to end in _ids, not _id.
  field = "#{field}_id" if model.class.reflect_on_association(field).present?
  if options[:index].present?
    if options[:array_name].present?
      if options[:base_name].present?
        "#{options[:base_name]}[#{options[:array_name]}[#{options[:index]}][#{field}]]"
      else
        "#{options[:array_name]}[#{options[:index]}][#{field}]"
      end
    else
      "#{model.class.to_s.underscore}[#{options[:index]}][#{field}]"
    end
  else
    "#{model.class.to_s.underscore}[#{field}]"
  end
end

#form_file(model, field, file_types = '.xlsx', classes = %w[s12 m6 l4 xl3])) ⇒ Object

File field



76
77
78
79
80
81
82
83
84
85
 
# File 'app/helpers/core_form_helper.rb', line 76

def form_file(model, field, file_types = '.xlsx', classes = %w[s12 m6 l4 xl3])
  form_name = form_field_name(model, field)
  form_id = "#{model.class.to_s.underscore}_#{field}"
  value = model.send(field)
  file_tag = tag(:input, id: form_id, name: form_name, type: :file, accept: file_types)
  content_tag(:div, class: (%w[input-field col] + classes).join(' ')) do
    concat(file_tag)
    concat(form_label_tag(model, field, value))
  end
end

#form_helper_text(model, field, default = nil) ⇒ String?

This method is abstract.

Get the helper text for this input element

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • default (String, nil) (defaults to: nil)

Returns:

  • (String, nil) 


199
200
201
 
# File 'app/helpers/core_form_helper.rb', line 199

def form_helper_text(model, field, default = nil)
  form_localized_text(model, field, :helpers, default)
end

#form_hint_tag(model, field) ⇒ Object

Get the hint for the field and add it



119
120
121
122
123
124
125
126
 
# File 'app/helpers/core_form_helper.rb', line 119

def form_hint_tag(model, field)
  key = "ui_form.#{model.class.to_s.underscore}.hints.#{field}"
  return nil unless I18n.exists?(key)

  content_tag(:p, class: 'form-hint', for: form_field_id(model, field)) do
    concat(I18n.t(key))
  end
end

#form_hint_text(model, field, default = nil) ⇒ String?

This method is abstract.

Get the hint text for this input element

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • default (String, nil) (defaults to: nil)

Returns:

  • (String, nil) 


208
209
210
 
# File 'app/helpers/core_form_helper.rb', line 208

def form_hint_text(model, field, default = nil)
  form_localized_text(model, field, :hints, default)
end

#form_label_tag(model, field, value, options = {}) ⇒ Object

get the label for field



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'app/helpers/core_form_helper.rb', line 90

def form_label_tag(model, field, value, options = {})
  # don't do a label if we are in default browser mode
  return if options[:no_label]
  return if options[:input_classes].present? && options[:input_classes].include?('browser-default')

  help_text = form_helper_text(model, field)

  # or if we have a prompt with now value
  place_holder = options[:place_holder] || form_place_holder_text(model, field)
  return if place_holder.blank? && value.blank? && options[:prompt].present?

  error = model.errors[field]
  classes = %w[form-label mb-2]
  classes << 'text-red' if error.present?
  options[:class] = classes.compact.uniq.join(' ')
  options[:for] = form_field_id(model, field, options)
  # options['data-error'] = error.join(', ') if error.present?
  options[:required] = form_required_field?(model, field) ? 'required' : nil
  tag.label(**options) do
    concat(input_label(model, field, field.to_s.humanize))
    concat(content_tag(:span, class: 'form-help ms-2', data: { bs_toggle: :popover, bs_content: help_text }) { '?' }) if help_text.present?
    # @todo CMS add handling specific errors later
    # concat(" #{error.join(', ')}") if error.present?
  end
end

#form_localized_text(model, field, type, default = nil) ⇒ String?

This method is abstract.

Get the localized value for the given key

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • type (Symbol)
  • default (String) (defaults to: nil)

Returns:

  • (String, nil) 


231
232
233
234
235
236
 
# File 'app/helpers/core_form_helper.rb', line 231

def form_localized_text(model, field, type, default = nil)
  key = ['ui_form', model.class.to_s.underscore, type, field].join('.')
  I18n.exists?(key) ? I18n.t(key) : default
rescue StandardError
  default
end

#form_place_holder_text(model, field, default = nil) ⇒ String?

This method is abstract.

Get the placeholder for this input element

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • default (String, nil) (defaults to: nil)

Returns:

  • (String, nil) 


190
191
192
 
# File 'app/helpers/core_form_helper.rb', line 190

def form_place_holder_text(model, field, default = nil)
  form_localized_text(model, field, :placeholders, default)
end

#form_radio_button(model, field, options = {}) ⇒ Object 



176
177
178
179
180
181
182
183
 
# File 'app/helpers/core_form_helper.rb', line 176

def form_radio_button(model, field, options = {})
  value = model.send(field)
  classes = (%w[input-field col] + options[:classes] || []).join(' ')
  content_tag(:div, class: classes) do
    concat(form_select_tag(model, field, options))
    concat(form_label_tag(model, field, value))
  end
end

#form_required_field?(model, field) ⇒ Boolean

This method is abstract.

Determine if the field is required or not

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)

Returns:

  • (Boolean) 


170
171
172
173
174
 
# File 'app/helpers/core_form_helper.rb', line 170

def form_required_field?(model, field)
  model.class.validators_on(field).any? { |v| v.is_a?(Mongoid::Validatable::PresenceValidator) }
rescue StandardError
  false
end

#form_select_option_key_values(value, options) ⇒ Object

Return an array of hashes for the selection to work easily



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'app/helpers/core_form_helper.rb', line 45

def form_select_option_key_values(value, options)
  select_options = []
  select_options << { key: '', value: options[:prompt], selected: false } if options[:prompt].present?
  options[:options].each do |option_value|
    option_value[:display_name] = option_value.display_name if option_value.respond_to?(:display_name)
    option_value[:display_name] = option_value.user_display_name if option_value.respond_to?(:user_display_name)
    select_options << case option_value
                      when String, Integer
                        { key: option_value,
                          value: option_value,
                          selected: value.eql?(option_value) }
                      when Array
                        { key: option_value.last,
                          value: option_value.first,
                          selected: value.to_s.eql?(option_value.last.to_s) }
                      when Hash
                        { key: option_value[:key],
                          value: option_value[:value],
                          selected: value.eql?(option_value[:key]) }
                      else
                        { key: option_value[:_id].to_s,
                          value: option_value[:display_name] || option_value[:name],
                          selected: value.eql?(option_value) }
                      end
  end
  select_options
end

#form_select_tag(model, field, options = {}) ⇒ Object

Create the select tag



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'app/helpers/core_form_helper.rb', line 27

def form_select_tag(model, field, options = {})
  select_content = {
    id: form_field_id(model, field, options),
    name: form_field_name(model, field, options),
    class: [options[:input_classes], 'materialize'].compact.join(' '),
    disabled: options[:disabled]
  }
  content_tag(:select, select_content) do
    form_select_option_key_values(model.send(field), options).each do |value|
      concat(content_tag(:option, value: value[:key], selected: value[:selected]) do
        concat(value[:value])
      end)
    end
  end
end

#form_time_field(model, field, options = {}) ⇒ Object

Time picker field



10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'app/helpers/core_form_helper.rb', line 10

def form_time_field(model, field, options = {})
  classes = options[:classes] || %w[s12 m6 l4 xl3]
  value = model.send(field)
  options[:value] = value
  options[:type] = :text
  options[:disabled] ||= false
  tag_options = text_field_options(model, field, options)
  tag_options[:class] = options[:time_picker_type] || 'time-picker'
  content_tag(:div, class: (%w[input-field col] + classes).join(' ')) do
    concat(tag(:input, tag_options))
    concat(form_label_tag(model, field, value, options))
  end
end

#input_label(model, field, default = model.class.human_attribute_name(field)) ⇒ String?

This method is abstract.

Get the label for this input element

Parameters:

  • model (Mongoid::Document)
  • field (Symbol)
  • default (String, nil) (defaults to: model.class.human_attribute_name(field))

Returns:

  • (String, nil) 


217
218
219
 
# File 'app/helpers/core_form_helper.rb', line 217

def input_label(model, field, default = model.class.human_attribute_name(field))
  form_localized_text(model, field, :labels, default)
end

#required_field?(model, field) ⇒ Boolean

Returns:

  • (Boolean) 


221
222
223
 
# File 'app/helpers/core_form_helper.rb', line 221

def required_field?(model, field)
  form_required_field?(model, field)
end