Class: AbAdmin::Views::SearchFormBuilder

Inherits:
Ransack::Helpers::FormBuilder
  • Object
show all
Defined in:
lib/ab_admin/views/search_form_builder.rb

Instance Method Summary collapse

Instance Method Details

#ac_select_field(attr, options = {}) ⇒ Object


50
51
52
53
54
55
56
57
# File 'lib/ab_admin/views/search_form_builder.rb', line 50

def ac_select_field(attr, options={})
  klass = options[:klass]
  options[:param] ||= "#{options[:value_attr] || attr}_eq"
  pre_select = params[:q].try!(:[], options[:param]) ? klass.where(id: params[:q][options[:param]]).map(&:for_input_token) : []
  options[:input_html] ||= {}
  options[:input_html].deep_merge! class: 'fancy_select', data: {class: klass.name, pre: pre_select.to_json}
  string_field attr, options
end

#ac_string_field(attr, options = {}) ⇒ Object


87
88
89
90
# File 'lib/ab_admin/views/search_form_builder.rb', line 87

def ac_string_field(attr, options={})
  options.reverse_deep_merge!({input_html: {class: 'ac_field', data: {class: @object.klass.name}}})
  string_field(attr, options)
end

#boolean_field(attr, options = {}) ⇒ Object


101
102
103
104
105
106
107
108
109
110
111
# File 'lib/ab_admin/views/search_form_builder.rb', line 101

def boolean_field(attr, options={})
  (:div, class: 'pull-left') do
    param = options[:param] || "#{attr}_eq"
    (:label, class: 'checkbox inline') do
      check_box_tag("q[#{param}]", 1, params[:q][param].to_i == 1, class: 'inline', id: "q_#{attr}") + I18n.t('simple_form.yes')
    end +
    (:label, class: 'checkbox inline') do
      check_box_tag("q[#{param}]", 0, params[:q][param] && params[:q][param].to_i == 0, class: 'inline') + I18n.t('simple_form.no')
    end
  end + label(attr, options[:label], class: 'right-label')
end

#conditional_wrapper(attr, options, &block) ⇒ Object


67
68
69
70
71
72
73
74
75
76
# File 'lib/ab_admin/views/search_form_builder.rb', line 67

def conditional_wrapper(attr, options, &block)
  if builder_options[:compact_labels]
    options[:input_html] ||= {}
    options[:input_html][:placeholder] ||= extract_label(attr, options)
    wrapper_html = {'class' => 'controls js-tooltip', 'data-placement' => 'left', 'title' => options[:input_html][:placeholder]}
    (:div, wrapper_html, &block)
  else
    label(attr, options[:label]) + (:div, class: 'controls', &block)
  end
end

#date_field(attr, options = {}) ⇒ Object


59
60
61
62
63
64
65
# File 'lib/ab_admin/views/search_form_builder.rb', line 59

def date_field(attr, options={})
  label(attr, options[:label]) + (:div, class: 'controls') do
    gt_param, lt_param = "#{attr}_gteq", "#{attr}_lteq"
    text_field_tag("q[#{gt_param}]", params[:q][gt_param], class: 'input-small datepicker', autocomplete: 'off') + ' - ' +
    text_field_tag("q[#{lt_param}]", params[:q][lt_param], class: 'input-small datepicker', autocomplete: 'off', id: "q_#{attr}")
  end
end

#extract_label(attr, options) ⇒ Object


131
132
133
# File 'lib/ab_admin/views/search_form_builder.rb', line 131

def extract_label(attr, options)
  options[:label].presence || @object.klass.han(attr)
end

#field_type(attr, options = {}) ⇒ Object


135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
# File 'lib/ab_admin/views/search_form_builder.rb', line 135

def field_type(attr, options={})
  return options[:as].to_sym if options[:as]
  return :string if attr =~ /^translations_/

  input_type = @object.klass.columns_hash[attr.to_s].try(:type)

  if input_type
    return :select if options[:collection]
    return :string if input_type == :text
  elsif @object.klass.try!(:translates?) && @object.klass.translated?(attr)
    options[:value_attr] = "translations_#{attr}"
    return :string
  elsif assoc = @object.klass.reflect_on_association(attr.to_sym)
    options[:collection] ||= assoc.klass.limit(500)
    options[:value_attr] = "#{attr}_id"
    return :select
  end

  case input_type
    when :timestamp, :datetime, :date
      :date
    when :decimal, :float, :integer
      :number
    else
      input_type or raise "No available input type for #{attr}"
  end
end

#hidden_field(attr, options = {}) ⇒ Object


122
123
124
# File 'lib/ab_admin/views/search_form_builder.rb', line 122

def hidden_field(attr, options={})
  hidden_field_tag("q[#{attr}_eq]", options[:value], options)
end

#input(attr, options = {}) ⇒ Object


10
11
12
13
14
15
16
17
# File 'lib/ab_admin/views/search_form_builder.rb', line 10

def input(attr, options={})
  field_type = field_type(attr, options)
  options[:wrapper_html] ||= {}
  options[:wrapper_html][:class] = "clearfix #{field_type} #{options[:wrapper_html][:class]}"
   :div, options[:wrapper_html] do
    public_send("#{field_type}_field", attr, options)
  end
end

#label(attr, text = nil, options = {}) ⇒ Object


126
127
128
129
# File 'lib/ab_admin/views/search_form_builder.rb', line 126

def label(attr, text=nil, options={})
  text ||= @object.klass.han(attr)
  super(attr, text, options)
end

#null_field(attr, options = {}) ⇒ Object


118
119
120
# File 'lib/ab_admin/views/search_form_builder.rb', line 118

def null_field(attr, options={})
  yes_no_field(attr, options.merge(predicates: {yes: %w(null 0), no: %w(null 1)}))
end

#number_field(attr, options = {}) ⇒ Object


92
93
94
95
96
97
98
99
# File 'lib/ab_admin/views/search_form_builder.rb', line 92

def number_field(attr, options={})
  label(attr, options[:label]) + (:div, class: 'controls') do
    opts = [['=', 'eq'], ['>', 'gt'], ['<', 'lt']].map { |m| [m[0], "#{attr}_#{m[1]}"] }
    current_filter = (opts.detect { |m| params[:q][m[1]].present? } || opts.first)[1]
    select_tag('', options_for_select(opts, current_filter), class: 'input-small predicate-select') +
    text_field_tag("q[#{current_filter}]", params[:q][current_filter], class: 'input-small', type: :number)
  end
end

#presence_field(attr, options = {}) ⇒ Object

Rails 4.2: Should be used only for string columns because of github.com/activerecord-hackery/ransack/issues/617


114
115
116
# File 'lib/ab_admin/views/search_form_builder.rb', line 114

def presence_field(attr, options={})
  yes_no_field(attr, options.merge(predicates: {yes: %w(present 1), no: %w(present 0)}))
end

#select_field(attr, options = {}) ⇒ Object


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# File 'lib/ab_admin/views/search_form_builder.rb', line 19

def select_field(attr, options={})
  conditional_wrapper attr, options do
    param = options[:param] || "#{options[:value_attr] || attr}_eq"

    if options[:collection].is_a?(Proc)
      collection = options[:collection].call
    else
      collection = options[:collection] || []
    end

    if collection.first.try(:respond_to?, :id)
      collection = collection.map{|r| [AbAdmin.display_name(r), r.id] }
    end

    options[:input_html] ||= {}
    options[:input_html][:id] = "q_#{attr}"

    if options[:fancy] || collection.length > 30
      options[:input_html][:class] = [options[:input_html][:class], 'fancy_select'].join(' ')
    end

    if options[:input_html][:placeholder]
      options[:input_html][:include_blank] = false
      options[:input_html][:prompt] ||= options[:input_html][:placeholder]
    else
      options[:input_html][:include_blank] = true
    end
    select_tag("q[#{param}]", options_for_select(collection, params[:q][param]), options[:input_html])
  end
end

#string_field(attr, options = {}) ⇒ Object


78
79
80
81
82
83
84
85
# File 'lib/ab_admin/views/search_form_builder.rb', line 78

def string_field(attr, options={})
  conditional_wrapper attr, options do
    param = options[:param] || "#{options[:value_attr] || attr}_cont"
    options[:input_html] ||= {}
    options[:input_html][:id] = "q_#{attr}"
    text_field_tag("q[#{param}]", params[:q][param], options[:input_html])
  end
end

#yes_no_field(attr, options = {}) ⇒ Object


163
164
165
166
167
168
169
170
171
172
173
174
175
# File 'lib/ab_admin/views/search_form_builder.rb', line 163

def yes_no_field(attr, options={})
  predicates = options[:predicates]
  (:div, class: 'pull-left') do
    (:label, class: 'checkbox inline') do
      param = "#{attr}_#{predicates[:yes][0]}"
      check_box_tag("q[#{param}]", predicates[:yes][1], params[:q][param] == predicates[:yes][1], class: 'inline', id: "q_#{attr}") + I18n.t('simple_form.yes')
    end +
    (:label, class: 'checkbox inline') do
      param = "#{attr}_#{predicates[:no][0]}"
      check_box_tag("q[#{param}]", predicates[:no][1], params[:q][param] == predicates[:no][1], class: 'inline') + I18n.t('simple_form.no')
    end
  end + label(attr, options[:label], class: 'right-label')
end