class Enolib::Fieldset

Attributes

instruction[R]
touched[R]

Public Class Methods

new(context, instruction, parent = nil) click to toggle source
Calls superclass method Enolib::ElementBase::new
# File lib/enolib/elements/fieldset.rb, line 7
def initialize(context, instruction, parent = nil)
  super(context, instruction, parent)

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

Public Instance Methods

_missing_error(entry) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 13
def _missing_error(entry)
  raise Errors::Validation.missing_element(@context, entry.key, @instruction, 'missing_fieldset_entry')
end
_untouched() click to toggle source
# File lib/enolib/elements/fieldset.rb, line 17
def _untouched
  return @instruction unless instance_variable_defined?(:@touched)

  untouched_entry = _entries.find { |entry| !entry.instance_variable_defined?(:@touched) }

  untouched_entry ? untouched_entry.instruction : false
end
all_entries_required(required = true) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 25
def all_entries_required(required = true)
  @all_entries_required = required
end
assert_all_touched(message = nil, except: nil, only: nil) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 29
def assert_all_touched(message = nil, except: nil, only: nil)
  message = Proc.new if block_given?

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

    entries.each do |entry|
      next if entry.touched  # TODO: Revisit instance var existance question in ruby

      if message.is_a?(Proc)
        message = message.call(entry)
      end

      raise Errors::Validation.unexpected_element(@context, message, entry[:instruction])
    end
  end
end
entries(key = nil) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 47
def entries(key = nil)
  @touched = true

  if key
    entries_map = _entries(map: true)
    entries_map.has_key?(key) ? entries_map[key] : []
  else
    _entries
  end
end
entry(key = nil) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 58
def entry(key = nil)
  _entry(key)
end
optional_entry(key) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 62
def optional_entry(key)
  _entry(key, required: false)
end
parent() click to toggle source
# File lib/enolib/elements/fieldset.rb, line 66
def parent
  @parent || Section.new(@context, @instruction[:parent])
end
required_entry(key = nil) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 70
def required_entry(key = nil)
  _entry(key, required: true)
end
to_s() click to toggle source
# File lib/enolib/elements/fieldset.rb, line 74
def to_s
  "#<Enolib::Fieldset key=#{@instruction[:key]} entries=#{_entries.length}>"
end
touch() click to toggle source
# File lib/enolib/elements/fieldset.rb, line 78
def touch
  @touched = true

  _entries.each(&:touch)
end

Private Instance Methods

_entries(map: false) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 86
def _entries(map: false)
  unless instance_variable_defined?(:@instantiated_entries)
    @instantiated_entries = []
    @instantiated_entries_map = {}
    instantiate_entries(@instruction)
  end

  map ? @instantiated_entries_map : @instantiated_entries
end
_entry(key = nil, required: nil) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 96
def _entry(key = nil, required: nil)
  @touched = true

  if key
    entries_map = _entries(map: true)
    entries = entries_map.has_key?(key) ? entries_map[key] : []
  else
    entries = _entries
  end

  if entries.empty?
    if required || required == nil && @all_entries_required
      raise Errors::Validation.missing_element(@context, key, @instruction, 'missing_fieldset_entry')
    elsif required == nil
      return MissingFieldsetEntry.new(key, self)
    else
      return nil
    end
  end

  if entries.length > 1
    raise Errors::Validation.unexpected_multiple_elements(
      @context,
      key,
      entries.map(&:instruction),
      'expected_single_fieldset_entry'
    )
  end

  entries[0]
end
instantiate_entries(fieldset) click to toggle source
# File lib/enolib/elements/fieldset.rb, line 128
def instantiate_entries(fieldset)
  if fieldset.has_key?(:mirror)
    instantiate_entries(fieldset[:mirror])
  elsif fieldset.has_key?(:entries)
    filtered = fieldset[:entries].reject { |entry| @instantiated_entries_map.has_key?(entry[:key]) }
    native_entries = filtered.map do |entry|
      instance = FieldsetEntry.new(@context, entry, self)

      if @instantiated_entries_map.has_key?(entry[:key])
        @instantiated_entries_map[entry[:key]].push(instance)
      else
        @instantiated_entries_map[entry[:key]] = [instance]
      end

      instance
    end

    instantiate_entries(fieldset[:extend]) if fieldset.has_key?(:extend)

    @instantiated_entries.concat(native_entries)
  end
end