Class: Enolib::Section

Inherits:
ElementBase show all
Defined in:
lib/enolib/elements/section.rb

Instance Method Summary collapse

Methods inherited from ElementBase

#comment_error, #error, #key, #key_error, #optional_comment, #optional_string_comment, #raw, #required_comment, #required_string_comment, #string_key

Constructor Details

#initialize(context, instruction, parent = nil) ⇒ Section 



7
8
9
10
11
 
# File 'lib/enolib/elements/section.rb', line 7

def initialize(context, instruction, parent = nil)
  super(context, instruction, parent)

  @all_elements_required = parent ? parent.all_elements_required? : false
end

Instance Method Details

#_missing_error(element) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/enolib/elements/section.rb', line 13

def _missing_error(element)
  case element
  when MissingField
    raise Errors::Validation.missing_element(@context, element.instance_variable_get(:@key), @instruction, 'missing_field')
  when MissingFieldset
    raise Errors::Validation.missing_element(@context, element.instance_variable_get(:@key), @instruction, 'missing_fieldset')
  when MissingList
    raise Errors::Validation.missing_element(@context, element.instance_variable_get(:@key), @instruction, 'missing_list')
  when MissingSection
    raise Errors::Validation.missing_element(@context, element.instance_variable_get(:@key), @instruction, 'missing_section')
  else
    raise Errors::Validation.missing_element(@context, element.instance_variable_get(:@key), @instruction, 'missing_element')
  end
end

#_untouched ⇒ Object 



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/enolib/elements/section.rb', line 28

def _untouched
  return @instruction unless instance_variable_defined?(:@touched)

  _elements.each do |element|
    untouched_element = element._untouched
    return untouched_element if untouched_element
  end

  false
end

#all_elements_required(required = true) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/enolib/elements/section.rb', line 39

def all_elements_required(required = true)
  @all_elements_required = required

  _elements.each do |element|
    if element.instruciton[:type] == :section && element.yielded?
      element.to_section.all_elements_required(required)
    elsif element.instruciton[:type] == :fieldset && element.yielded?
      element.to_fieldset.all_entries_required(required)
    end
  end
end

#all_elements_required? ⇒ Boolean 



51
52
53
 
# File 'lib/enolib/elements/section.rb', line 51

def all_elements_required?
  @all_elements_required
end

#assert_all_touched(message = nil, except: nil, only: nil) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/enolib/elements/section.rb', line 55

def assert_all_touched(message = nil, except: nil, only: nil)
  message = Proc.new if block_given?

  _elements(map: true).each do |key, elements|
    next if except && except.include?(key) || only && !only.include?(key)

    elements.each do |element|
      untouched = element._untouched

      next unless untouched

      if message.is_a?(Proc)
        message = message.call(Element.new(@context, untouched, self))
      end

      raise Errors::Validation.unexpected_element(@context, message, untouched)
    end
  end
end

#element(key = nil) ⇒ Object 



75
76
77
 
# File 'lib/enolib/elements/section.rb', line 75

def element(key = nil)
  _element(key)
end

#elements(key = nil) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
 
# File 'lib/enolib/elements/section.rb', line 79

def elements(key = nil)
  @touched = true

  if key
    elements_map = _elements(map: true)
    elements_map.has_key?(key) ? elements_map[key] : []
  else
    _elements
  end
end

#empty(key = nil) ⇒ Object 



90
91
92
 
# File 'lib/enolib/elements/section.rb', line 90

def empty(key = nil)
  _empty(key)
end

#field(key = nil) ⇒ Object 



94
95
96
 
# File 'lib/enolib/elements/section.rb', line 94

def field(key = nil)
  _field(key)
end

#fields(key = nil) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/enolib/elements/section.rb', line 98

def fields(key = nil)
  @touched = true

  if key
    elements_map = _elements(map: true)
    elements = elements_map.has_key?(key) ? elements_map[key] : []
  else
    elements = _elements
  end

  elements.map do |element|
    unless element.yields_field?
      raise Errors::Validation.unexpected_element_type(
        @context,
        key,
        element.instruction,
        'expected_fields'
      )
    end

    element.to_field
  end
end

#fieldset(key = nil) ⇒ Object 



122
123
124
 
# File 'lib/enolib/elements/section.rb', line 122

def fieldset(key = nil)
  _fieldset(key)
end

#fieldsets(key = nil) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/enolib/elements/section.rb', line 126

def fieldsets(key = nil)
  @touched = true

  if key
    elements_map = _elements(map: true)
    elements = elements_map.has_key?(key) ? elements_map[key] : []
  else
    elements = _elements
  end

  elements.map do |element|
    unless element.yields_fieldset?
      raise Errors::Validation.unexpected_element_type(
        @context,
        key,
        element.instruction,
        'expected_fieldsets'
      )
    end

    element.to_fieldset
  end
end

#list(key = nil) ⇒ Object 



150
151
152
 
# File 'lib/enolib/elements/section.rb', line 150

def list(key = nil)
  _list(key)
end

#lists(key = nil) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/enolib/elements/section.rb', line 154

def lists(key = nil)
  @touched = true

  if key
    elements_map = _elements(map: true)
    elements = elements_map.has_key?(key) ? elements_map[key] : []
  else
    elements = _elements
  end

  elements.map do |element|
    unless element.yields_list?
      raise Errors::Validation.unexpected_element_type(
        @context,
        key,
        element.instruction,
        'expected_lists'
      )
    end

    element.to_list
  end
end

#optional_element(key = nil) ⇒ Object 



178
179
180
 
# File 'lib/enolib/elements/section.rb', line 178

def optional_element(key = nil)
  _element(key, required: false)
end

#optional_empty(key = nil) ⇒ Object 



182
183
184
 
# File 'lib/enolib/elements/section.rb', line 182

def optional_empty(key = nil)
  _empty(key, required: false)
end

#optional_field(key = nil) ⇒ Object 



186
187
188
 
# File 'lib/enolib/elements/section.rb', line 186

def optional_field(key = nil)
  _field(key, required: false)
end

#optional_fieldset(key = nil) ⇒ Object 



190
191
192
 
# File 'lib/enolib/elements/section.rb', line 190

def optional_fieldset(key = nil)
  _fieldset(key, required: false)
end

#optional_list(key = nil) ⇒ Object 



194
195
196
 
# File 'lib/enolib/elements/section.rb', line 194

def optional_list(key = nil)
  _list(key, required: false)
end

#optional_section(key = nil) ⇒ Object 



198
199
200
 
# File 'lib/enolib/elements/section.rb', line 198

def optional_section(key = nil)
  _section(key, required: false)
end

#parent ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/enolib/elements/section.rb', line 202

def parent
  if @instruction[:type] == :document
    nil
  else
    @parent || Section.new(@context, @instruction[:parent])
  end
end

#required_element(key = nil) ⇒ Object 



210
211
212
 
# File 'lib/enolib/elements/section.rb', line 210

def required_element(key = nil)
  _element(key, required: true)
end

#required_empty(key = nil) ⇒ Object 



214
215
216
 
# File 'lib/enolib/elements/section.rb', line 214

def required_empty(key = nil)
  _empty(key, required: true)
end

#required_field(key = nil) ⇒ Object 



218
219
220
 
# File 'lib/enolib/elements/section.rb', line 218

def required_field(key = nil)
  _field(key, required: true)
end

#required_fieldset(key = nil) ⇒ Object 



222
223
224
 
# File 'lib/enolib/elements/section.rb', line 222

def required_fieldset(key = nil)
  _fieldset(key, required: true)
end

#required_list(key = nil) ⇒ Object 



226
227
228
 
# File 'lib/enolib/elements/section.rb', line 226

def required_list(key = nil)
  _list(key, required: true)
end

#required_section(key = nil) ⇒ Object 



230
231
232
 
# File 'lib/enolib/elements/section.rb', line 230

def required_section(key = nil)
  _section(key, required: true)
end

#section(key = nil) ⇒ Object 



234
235
236
 
# File 'lib/enolib/elements/section.rb', line 234

def section(key = nil)
  _section(key)
end

#sections(key = nil) ⇒ Object 



238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/enolib/elements/section.rb', line 238

def sections(key = nil)
  @touched = true

  if key
    elements_map = _elements(map: true)
    elements = elements_map.has_key?(key) ? elements_map[key] : []
  else
    elements = _elements
  end

  elements.map do |element|
    unless element.yields_section?
      raise Errors::Validation.unexpected_element_type(
        @context,
        key,
        element.instruction,
        'expected_sections'
      )
    end

    element.to_section
  end
end

#to_s ⇒ Object 



262
263
264
265
266
267
268
 
# File 'lib/enolib/elements/section.rb', line 262

def to_s
  if @instruction[:type] == :document
    "#<Enolib::Section document elements=#{elements.length}>"
  else
    "#<Enolib::Section key=#{@instruction[:key]} elements=#{elements.length}>"
  end
end

#touch ⇒ Object 



270
271
272
273
274
 
# File 'lib/enolib/elements/section.rb', line 270

def touch
  @touched = true

  _elements.each(&:touch)
end