Module: RailsAdmin::Config::HasFields

Included in:
Sections::Export, Sections::List, Sections::Show
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

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

exclude fields by name or by condition (block)



54
55
56
57
58
 
# File 'lib/rails_admin/config/has_fields.rb', line 54

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, &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
 
# File 'lib/rails_admin/config/has_fields.rb', line 6

def field(name, type = nil, &block)
  field = @fields.find {|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
  field.show if field.try(:hidden?)

  # 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, {})).last

  # Register a custom field type if one is provided and it is different from
  # one found in default stack
  elsif !type.nil? && type != (field.nil? ? nil : field.type)
    @fields.delete(field) unless field.nil?
    properties = parent.abstract_model.properties.find {|p| name == p[:name] }
    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
  unless 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
  if block
    field.instance_eval &block
    @fields.sort! {|a, b| a.order <=> b.order }
  end
  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



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/rails_admin/config/has_fields.rb', line 75

def fields(*field_names,&block)
  if field_names.empty?
    defined = @fields.select {|f| f.defined }
    defined.sort! {|a, b| a.order <=> b.order }
    defined = @fields if defined.empty?
    if block
      defined.each {|f| f.instance_eval &block }
    end
    defined
  else
    defined = field_names.map{|field_name| @fields.find {|f| f.name == field_name } }
    defined.map do |f|
      unless f.defined
        f.defined = true
        f.order = @fields.select(&:defined).length
      end
      f.instance_eval(&block) if block
      f
    end
  end
end

#fields_of_type(type, &block) ⇒ Object

Defines configuration for fields by their type.



98
99
100
101
102
103
104
 
# File 'lib/rails_admin/config/has_fields.rb', line 98

def fields_of_type(type, &block)
  selected = @fields.select {|f| type == f.type }
  if block
    selected.each {|f| f.instance_eval &block }
  end
  selected
end

#include_all_fields ⇒ Object

does pretty much what it says in the can



65
66
67
 
# File 'lib/rails_admin/config/has_fields.rb', line 65

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



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/rails_admin/config/has_fields.rb', line 40

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

#visible_fields ⇒ Object

Get all fields defined as visible.



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

def visible_fields
  fields.select {|f| f.with(bindings).visible? }.map{|f| f.with(bindings)}
end