Module: RailsAdmin::Config::HasFields

Included in:
Sections::Base
Defined in:
lib/rails_admin/config/has_fields.rb

Overview

Provides accessors and autoregistering of model's fields.

Instance Method Summary collapse

Instance Method Details

#_fields(readonly = false) ⇒ Object (protected)

Raw fields. Recursively returns parent section's raw fields Duping it if accessed for modification.


125
126
127
128
129
130
131
132
133
134
135
136
# File 'lib/rails_admin/config/has_fields.rb', line 125

def _fields(readonly = false)
  return @_fields if @_fields
  return @_ro_fields if readonly && @_ro_fields

  if self.class == RailsAdmin::Config::Sections::Base
    @_ro_fields = @_fields = RailsAdmin::Config::Fields.factory(self)
  else
    # parent is RailsAdmin::Config::Model, recursion is on Section's classes
    @_ro_fields ||= parent.send(self.class.superclass.to_s.underscore.split('/').last)._fields(true).freeze
  end
  readonly ? @_ro_fields : (@_fields ||= @_ro_fields.collect(&:clone))
end

#all_fieldsObject

Accessor for all fields


107
108
109
110
111
112
# File 'lib/rails_admin/config/has_fields.rb', line 107

def all_fields
  ((ro_fields = _fields(true)).select(&:defined).presence || ro_fields).collect do |f|
    f.section = self
    f
  end
end

#configure(name, type = nil, &block) ⇒ Object

configure a field without adding it.


43
44
45
# File 'lib/rails_admin/config/has_fields.rb', line 43

def configure(name, type = nil, &block)
  field(name, type, false, &block)
end

#exclude_fields(*field_names, &block) ⇒ Object Also known as: exclude_fields_if

exclude fields by name or by condition (block)


62
63
64
65
66
# File 'lib/rails_admin/config/has_fields.rb', line 62

def exclude_fields(*field_names, &block)
  block ||= lambda { |f| field_names.include?(f.name) }
  _fields.each { |f| f.defined = true } if _fields.select(&:defined).empty?
  _fields.select { |f| f.instance_eval(&block) }.each { |f| f.defined = false }
end

#field(name, type = nil, add_to_section = true, &block) ⇒ Object

Defines a configuration for a field.


6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# File 'lib/rails_admin/config/has_fields.rb', line 6

def field(name, type = nil, add_to_section = true, &block)
  field = _fields.detect { |f| name == f.name }

  # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
  # unhide them if config specifically defines them
  if field
    field.show unless field.instance_variable_get("@#{field.name}_registered").is_a?(Proc)
  end
  # Specify field as virtual if type is not specifically set and field was not
  # found in default stack
  if field.nil? && type.nil?
    field = (_fields << RailsAdmin::Config::Fields::Types.load(:string).new(self, name, nil)).last

  # Register a custom field type if one is provided and it is different from
  # one found in default stack
  elsif type && type != (field.nil? ? nil : field.type)
    if field
      properties = field.properties
      _fields.delete(field)
    else
      properties = abstract_model.properties.detect { |p| name == p.name }
    end
    field = (_fields <<  RailsAdmin::Config::Fields::Types.load(type).new(self, name, properties)).last
  end

  # If field has not been yet defined add some default properties
  if add_to_section && !field.defined
    field.defined = true
    field.order = _fields.select(&:defined).length
  end

  # If a block has been given evaluate it and sort fields after that
  field.instance_eval(&block) if block
  field
end

#fields(*field_names, &block) ⇒ Object

Returns all field configurations for the model configuration instance. If no fields have been defined returns all fields. Defined fields are sorted to match their order property. If order was not specified it will match the order in which fields were defined.

If a block is passed it will be evaluated in the context of each field


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
# File 'lib/rails_admin/config/has_fields.rb', line 82

def fields(*field_names, &block)
  return all_fields if field_names.empty? && !block

  if field_names.empty?
    defined = _fields.select(&:defined)
    defined = _fields if defined.empty?
  else
    defined = field_names.collect { |field_name| _fields.detect { |f| f.name == field_name } }
  end
  defined.collect do |f|
    unless f.defined
      f.defined = true
      f.order = _fields.select(&:defined).length
    end
    f.instance_eval(&block) if block
    f
  end
end

#fields_of_type(type, &block) ⇒ Object

Defines configuration for fields by their type.


102
103
104
# File 'lib/rails_admin/config/has_fields.rb', line 102

def fields_of_type(type, &block)
  _fields.select { |f| type == f.type }.map! { |f| f.instance_eval(&block) } if block
end

#include_all_fieldsObject


72
73
74
# File 'lib/rails_admin/config/has_fields.rb', line 72

def include_all_fields
  include_fields_if { true }
end

#include_fields(*field_names, &block) ⇒ Object Also known as: include_fields_if

include fields by name and apply an optionnal block to each (through a call to fields), or include fields by conditions if no field names


49
50
51
52
53
54
55
56
57
58
59
# File 'lib/rails_admin/config/has_fields.rb', line 49

def include_fields(*field_names, &block)
  if field_names.empty?
    _fields.select { |f| f.instance_eval(&block) }.each do |f|
      next if f.defined
      f.defined = true
      f.order = _fields.select(&:defined).length
    end
  else
    fields(*field_names, &block)
  end
end

#visible_fieldsObject

Get all fields defined as visible, in the correct order.


115
116
117
118
# File 'lib/rails_admin/config/has_fields.rb', line 115

def visible_fields
  i = 0
  all_fields.collect { |f| f.with(bindings) }.select(&:visible?).sort_by { |f| [f.order, i += 1] } # stable sort, damn
end