enolib 0.5.0

data/lib/enolib/elements/empty.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Empty < ElementBase
+    def to_s
+      "#<Enolib::Empty key=#{@instruction[:key]}>"
+    end
+  end
+end

data/lib/enolib/elements/field.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Field < ValueElementBase
+    def optional_string_value
+      _value(required: false)
+    end
+
+    def optional_value(loader = nil)
+      loader = Proc.new if block_given?
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _value(loader, required: false)
+    end
+
+    def parent
+      return @parent || Section.new(@context, @instruction[:parent])
+    end
+
+    def required_string_value
+      _value(required: true)
+    end
+
+    def required_value(loader = nil)
+      loader = Proc.new if block_given?
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _value(loader, required: true)
+    end
+
+    def to_s
+      "#<Enolib::Field key=#{@instruction[:key]} value=#{print_value}>"
+    end
+
+    private
+
+    def _value(loader = nil, required:)
+      @touched = true
+
+      value = @context.value(@instruction)
+
+      if value
+        return value unless loader
+
+        begin
+          loader.call(value)
+        rescue => message
+          raise Errors::Validation.value_error(@context, message, @instruction)
+        end
+      else
+        return nil unless required
+
+        raise Errors::Validation.missing_value(@context, @instruction)
+      end
+    end
+  end
+end

data/lib/enolib/elements/fieldset.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Fieldset < ElementBase
+    attr_reader :instruction, :touched
+
+    def initialize(context, instruction, parent = nil)
+      super(context, instruction, parent)
+
+      @all_entries_required = parent ? parent.all_elements_required? : false
+    end
+
+    def _missing_error(entry)
+      raise Errors::Validation.missing_element(@context, entry.key, @instruction, 'missing_fieldset_entry')
+    end
+
+    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
+
+    def all_entries_required(required = true)
+      @all_entries_required = required
+    end
+
+    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|
+          unless 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
+    end
+
+    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
+
+    def entry(key = nil)
+      _entry(key)
+    end
+
+    def optional_entry(key)
+      _entry(key, optional: true)
+    end
+
+    def parent
+      @parent || Section.new(@context, @instruction[:parent])
+    end
+
+    def required_entry(key = nil)
+      _entry(key, required: true)
+    end
+
+    def to_s
+      "#<Enolib::Fieldset key=#{@instruction[:key]} entries=#{_entries.length}>"
+    end
+
+    def touch
+      @touched = true
+
+      _entries.each(&:touch)
+    end
+
+    private
+
+    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
+
+    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 || @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
+
+    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
+  end
+end

data/lib/enolib/elements/fieldset_entry.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Enolib
+  class FieldsetEntry < ValueElementBase
+    attr_reader :instruction # TODO: Revisit this hacky exposition
+    
+    def parent
+      @parent || Fieldset.new(@context, @instruction[:parent])
+    end
+
+    def to_s
+      "#<Enolib::FieldsetEntry key=#{@instruction[:key]} value=#{print_value}>"
+    end
+  end
+end

data/lib/enolib/elements/list.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Enolib
+  class List < ElementBase
+    attr_reader :instruction
+
+    def _instantiate_items(list)
+      if list.has_key?(:mirror)
+        _instantiate_items(list[:mirror])
+      elsif list.has_key?(:extend)
+        _instantiate_items(list[:extend]) + list[:items].map { |item| ListItem.new(@context, item, self) }
+      elsif list.has_key?(:items)
+        list[:items].map { |item| ListItem.new(@context, item, self) }
+      else
+        []
+      end
+    end
+
+    def _items
+      unless instance_variable_defined?(:@instantiated_items)
+        @instantiated_items = _instantiate_items(@instruction)
+      end
+
+      @instantiated_items
+    end
+
+    def _untouched
+      return @instruction unless instance_variable_defined?(:@touched)
+
+      untouched_item = _items.find { |item| !item.instance_variable_defined?(:@touched) }
+
+      untouched_item ? untouched_item.instruction : false
+    end
+
+    def items
+      @touched = true
+
+      _items
+    end
+
+    def length
+      @touched = true
+
+      _items.length
+    end
+
+    def optional_comment(loader = nil)
+      loader = Proc.new if block_given?
+
+      if loader
+        _comment(loader, required: false)
+      else
+        raise ArgumentError.new('A loader block or Proc must be provided')
+      end
+    end
+
+    def optional_string_values
+      @touched = true
+
+      _items.map(&:optional_string_value)
+    end
+
+    def optional_values(loader = nil)
+      loader = Proc.new if block_given?
+
+      @touched = true
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _items.map { |item| item.optional_value(loader) }
+    end
+
+    def parent
+      @parent || Section.new(@context, @instruction[:parent])
+    end
+
+    def required_string_values
+      @touched = true
+
+      _items.map(&:required_string_value)
+    end
+
+    def required_values(loader = nil)
+      loader = Proc.new if block_given?
+
+      @touched = true
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _items.map { |item| item.required_value(loader) }
+    end
+
+    def to_s
+      "#<Enolib::List key=#{@instruction[:key]} items=#{_items.length}>"
+    end
+
+    def touch
+      @touched = true
+
+      _items.each(&:touch)
+    end
+  end
+end

data/lib/enolib/elements/list_item.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Enolib
+  class ListItem < ValueElementBase
+    def parent
+      @parent || List.new(@context, @instruction[:parent])
+    end
+
+    def to_s
+      "#<Enolib::ListItem value=#{print_value}>"
+    end
+  end
+end

data/lib/enolib/elements/missing/missing_element_base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Enolib
+  class MissingElementBase
+    attr_reader :parent
+
+    def initialize(key, parent)
+      @key = key
+      @parent = parent
+    end
+
+    def _missing_error(_element)
+      @parent._missing_error(self)
+    end
+
+    def key(_loader)
+      @parent._missing_error(self)
+    end
+
+    def optional_comment(_loader)
+      nil
+    end
+
+    def optional_string_comment
+      nil
+    end
+
+    def raw
+      nil
+    end
+
+    def required_comment(_loader)
+      @parent._missing_error(self)
+    end
+
+    def required_string_comment
+      @parent._missing_error(self)
+    end
+
+    def string_key
+      @parent._missing_error(self)
+    end
+  end
+end

data/lib/enolib/elements/missing/missing_empty.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Enolib
+  class MissingEmpty < MissingElementBase
+    def to_s
+      if @key
+        "#<Enolib::MissingEmpty key=#{@key}>"
+      else
+        '#<Enolib::MissingEmpty>'
+      end
+    end
+  end
+end

data/lib/enolib/elements/missing/missing_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Enolib
+  class MissingField < MissingValueElementBase
+    def to_s
+      if @key
+        "#<Enolib::MissingField key=#{@key}>"
+      else
+        '#<Enolib::MissingField>'
+      end
+    end
+  end
+end

data/lib/enolib/elements/missing/missing_fieldset.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Enolib
+  class MissingFieldset < MissingElementBase
+    def entries(_key = nil)
+      []
+    end
+
+    def entry(key = nil)
+      MissingFieldsetEntry.new(key, self)
+    end
+
+    def optional_entry(_key = nil)
+      nil
+    end
+
+    def required_entry(_key = nil)
+      @parent._missing_error(self)
+    end
+
+    def to_s
+      if @key
+        "#<Enolib::MissingFieldset key=#{@key}>"
+      else
+        '#<Enolib::MissingFieldset>'
+      end
+    end
+  end
+end