enolib 0.5.0

data/lib/enolib/elements/section_element.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Enolib
+  class SectionElement < ElementBase
+    attr_reader :instruction # TODO: Revisit this hacky exposition
+
+    def _untouched
+      return @instruction unless instance_variable_defined?(:@yielded)
+
+      return @instruction if instance_variable_defined?(:@empty) && !@empty.instance_variable_defined?(:@touched)
+      return @instruction if instance_variable_defined?(:@field) && !@field.instance_variable_defined?(:@touched)
+      return @fieldset._untouched if instance_variable_defined?(:@fieldset)
+      return @list._untouched if instance_variable_defined?(:@list)
+      return @section._untouched if instance_variable_defined?(:@section)
+    end
+
+    def to_empty
+      unless instance_variable_defined?(:@empty)
+        if instance_variable_defined?(:@yielded)
+          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as an empty.")
+        end
+
+        unless @instruction[:type] == :empty_element
+          # TODO: Below and in all implementations - why nil for key as second parameter?
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_empty')
+        end
+
+        @empty = Empty.new(@context, @instruction, @parent)
+        @yielded = :empty_element
+      end
+
+      @empty
+    end
+
+    def to_field
+      unless instance_variable_defined?(:@field)
+        if instance_variable_defined?(:@yielded)
+          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a field.")
+        end
+
+        unless @instruction[:type] == :field ||
+               @instruction[:type] == :multiline_field_begin ||
+               @instruction[:type] == :empty_element
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_field')
+        end
+
+        @field = Field.new(@context, @instruction, @parent)
+        @yielded = :field
+      end
+
+      @field
+    end
+
+    def to_fieldset
+      unless instance_variable_defined?(:@fieldset)
+        if instance_variable_defined?(:@yielded)
+          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a fieldset.")
+        end
+
+        unless @instruction[:type] == :fieldset || @instruction[:type] == :empty_element
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_fieldset')
+        end
+
+        @fieldset = Fieldset.new(@context, @instruction, @parent)
+        @yielded = :fieldset
+      end
+
+      @fieldset
+    end
+
+    def to_list
+      unless instance_variable_defined?(:@list)
+        if instance_variable_defined?(:@yielded)
+          raise TypeError.new("This element was already yielded as #{PRETTY_TYPES[@yielded]} and can't be yielded again as a list.")
+        end
+
+        unless @instruction[:type] == :list || @instruction[:type] == :empty_element
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_list')
+        end
+
+        @list = List.new(@context, @instruction, @parent)
+        @yielded = :list
+      end
+
+      @list
+    end
+
+    def to_section
+      unless instance_variable_defined?(:@section)
+        unless @instruction[:type] == :section
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_section')
+        end
+
+        @section = Section.new(@context, @instruction, @parent)
+        @yielded = :section
+      end
+
+      @section
+    end
+
+    def touch
+      # TODO: Here and other implementations: This needs to touch anyway; possibly not so small implications
+      return unless instance_variable_defined?(:@yielded)
+
+      # TODO: Revisit setting touched on foreign instances
+      @empty.touched = true if instance_variable_defined?(:@empty)
+      @field.touched = true if instance_variable_defined?(:@field)
+      @fieldset.touch if instance_variable_defined?(:@fieldset)
+      @list.touch if instance_variable_defined?(:@list)
+      @section.touch if instance_variable_defined?(:@section)
+    end
+
+    def yields_empty?
+      @instruction[:type] == :empty_element
+    end
+
+    def yields_field?
+      @instruction[:type] == :field ||
+      @instruction[:type] == :multiline_field_begin ||
+      @instruction[:type] == :empty_element
+    end
+
+    def yields_fieldset?
+      @instruction[:type] == :fieldset ||
+      @instruction[:type] == :empty_element
+    end
+
+    def yields_list?
+      @instruction[:type] == :list ||
+      @instruction[:type] == :empty_element
+    end
+
+    def yields_section?
+      @instruction[:type] == :section
+    end
+
+    def to_s
+      "#<Enolib::SectionElement key=#{@instruction[:key]}>"
+    end
+  end
+end

data/lib/enolib/elements/value_element_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Enolib
+  class ValueElementBase < ElementBase
+    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 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 value_error(message = nil)
+      if block_given?
+        message = yield(@context.value(@instruction))
+      elsif message.is_a?(Proc)
+        message = message.call(@context.value(@instruction))
+      end
+
+      unless message
+        raise ArgumentError.new('A message or message function must be provided')
+      end
+
+      Errors::Validation.value_error(@context, message, @instruction)
+    end
+
+    private
+
+    def print_value
+      value = @context.value(@instruction)
+
+      return 'nil' unless value
+
+      value = "#{value[0..10]}..." if value.length > 14
+
+      value.gsub("\n", '\n')
+    end
+
+    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/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Error < StandardError
+    attr_reader :selection, :snippet, :text
+
+    def initialize(text, snippet, selection)
+      super("#{text}\n\n#{snippet}")
+
+      @selection = selection
+      @snippet = snippet
+      @text = text
+    end
+
+    def cursor
+      @selection[0]
+    end
+  end
+
+  class ParseError < Error
+  end
+
+  class ValidationError < Error
+  end
+end

data/lib/enolib/errors/parsing.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Enolib
+  module Errors
+    module Parsing
+      UNTERMINATED_ESCAPED_KEY = /^\s*#*\s*(`+)(?!`)((?:(?!\1).)+)$/
+
+      def self.cyclic_dependency(context, instruction, instruction_chain)
+        first_occurrence = instruction_chain.find_index(instruction)
+        feedback_chain = instruction_chain[first_occurrence..-1]
+
+        if feedback_chain.last.has_key?(:template)
+          copy_instruction = feedback_chain.last
+        elsif feedback_chain.first.has_key?(:template)  # TODO: Here and elsewhere, do we even need to check this? One has to be it, right?
+          copy_instruction = feedback_chain.first
+        end
+
+        reporter = context.reporter.new(context)
+
+        reporter.report_line(copy_instruction)
+
+        feedback_chain.each do |element|
+          reporter.indicate_line(element) if element != copy_instruction
+        end
+
+        ParseError.new(
+          context.messages::cyclic_dependency(copy_instruction[:line] + Enolib::HUMAN_INDEXING, copy_instruction[:template]),
+          reporter.snippet,
+          Selections::select_template(copy_instruction)
+        )
+      end
+
+      def self.invalid_line(context, instruction)
+        line = context.input[instruction[:ranges][:line][RANGE_BEGIN]..instruction[:ranges][:line][RANGE_END]]
+
+        match = UNTERMINATED_ESCAPED_KEY.match(line)
+        return unterminated_escaped_key(context, instruction, match.end(1)) if match
+
+        ParseError.new(
+          context.messages::invalid_line(instruction[:line] + Enolib::HUMAN_INDEXING),
+          context.reporter.new(context).report_line(instruction).snippet,
+          Selections::select_line(instruction)
+        )
+      end
+
+      def self.missing_element_for_continuation(context, continuation)
+        ParseError.new(
+          context.messages::missing_element_for_continuation(continuation[:line] + Enolib::HUMAN_INDEXING),
+          context.reporter.new(context).report_line(continuation).snippet,
+          Selections::select_line(continuation)
+        )
+      end
+
+      def self.missing_fieldset_for_fieldset_entry(context, entry)
+        ParseError.new(
+          context.messages::missing_fieldset_for_fieldset_entry(entry[:line] + Enolib::HUMAN_INDEXING),
+          context.reporter.new(context).report_line(entry).snippet,
+          Selections::select_line(entry)
+        )
+      end
+
+      def self.missing_list_for_list_item(context, item)
+        ParseError.new(
+          context.messages::missing_list_for_list_item(item[:line] + Enolib::HUMAN_INDEXING),
+          context.reporter.new(context).report_line(item).snippet,
+          Selections::select_line(item)
+        )
+      end
+
+      def self.non_section_element_not_found(context, copy)
+        ParseError.new(
+          context.messages::non_section_element_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
+          context.reporter.new(context).report_line(copy).snippet,
+          Selections::select_line(copy)
+        )
+      end
+
+      def self.section_hierarchy_layer_skip(context, section, super_section)
+        reporter = context.reporter.new(context).report_line(section)
+
+        reporter.indicate_line(super_section) if super_section[:type] != :document
+
+        ParseError.new(
+          context.messages::section_hierarchy_layer_skip(section[:line] + Enolib::HUMAN_INDEXING),
+          reporter.snippet,
+          Selections::select_line(section)
+        )
+      end
+
+      def self.section_not_found(context, copy)
+        ParseError.new(
+          context.messages::section_not_found(copy[:line] + Enolib::HUMAN_INDEXING, copy[:template]),
+          context.reporter.new(context).report_line(copy).snippet,
+          Selections::select_line(copy)
+        )
+      end
+
+      def self.unterminated_escaped_key(context, instruction, selection_column)
+        ParseError.new(
+          context.messages::unterminated_escaped_key(instruction[:line] + Enolib::HUMAN_INDEXING),
+          context.reporter.new(context).report_line(instruction).snippet,
+          {
+            from: {
+              column: selection_column,
+              index: instruction[:ranges][:line][RANGE_BEGIN] + selection_column,
+              line: instruction[:line]
+            },
+            to: Selections::cursor(instruction, :line, RANGE_END)
+          }
+        )
+      end
+
+      def self.two_or_more_templates_found(context, copy, first_template, second_template)
+        ParseError.new(
+          context.messages::two_or_more_templates_found(copy[:template]),
+          context.reporter.new(context).report_line(copy).question_line(first_template).question_line(second_template).snippet,
+          Selections::select_line(copy)
+        )
+      end
+
+      def self.unterminated_multiline_field(context, field)
+        reporter = context.reporter.new(context).report_element(field)
+
+        context.meta.each do |instruction|
+          reporter.indicate_line(instruction) if instruction[:line] > field[:line]
+        end
+
+        ParseError.new(
+          context.messages::unterminated_multiline_field(field[:key], field[:line] + Enolib::HUMAN_INDEXING),
+          reporter.snippet,
+          Selections::select_line(field)
+        )
+      end
+    end
+  end
+end

data/lib/enolib/errors/selections.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Enolib
+  module Selections
+    RANGE_BEGIN = 0
+    RANGE_END = 1
+    DOCUMENT_BEGIN = {
+      from: { column: 0, index: 0, line: 0 },
+      to: { column: 0, index: 0, line: 0 }
+    }
+
+    def self.last_in(element)
+      if (element[:type] == :field ||
+          element[:type] == :list_item ||
+          element[:type] == :fieldset_entry) && element.has_key?(:continuations)
+        element[:continuations].last
+      elsif element[:type] == :list && element.has_key?(:items)
+        last_in(element[:items].last)
+      elsif element[:type] == :fieldset && element.has_key?(:entries)
+        last_in(element[:entries].last)
+      elsif element[:type] == :multiline_field_begin
+        element[:end]
+      elsif element[:type] == :section && !element[:elements].empty?
+        last_in(element[:elements].last)
+      else
+        element
+      end
+    end
+
+    def self.cursor(instruction, range, position)
+      index = instruction[:ranges][range][position]
+
+      {
+        column: index - instruction[:ranges][:line][RANGE_BEGIN],
+        index: index,
+        line: instruction[:line]
+      }
+    end
+
+    def self.selection(instruction, range, position, *to)
+      to_instruction = to.find { |argument| argument.is_a?(Hash) } || instruction
+      to_range = to.find { |argument| argument.is_a?(Symbol) } || range
+      to_position = to.find { |argument| argument.is_a?(Numeric) } || position
+
+      {
+        from: cursor(instruction, range, position),
+        to: cursor(to_instruction, to_range, to_position)
+      }
+    end
+
+    def self.select_comments(element)
+      comments = element[:comments]
+
+      if comments.length == 1
+        if comments.first.has_key?(:comment)
+          selection(comments.first, :comment, RANGE_BEGIN, RANGE_END)
+        else
+          selection(comments.first, :line, RANGE_BEGIN, RANGE_END)
+        end
+      elsif comments.length > 1
+        selection(comments.first, :line, RANGE_BEGIN, comments.last, :line, RANGE_END)
+      else
+        selection(element, :line, RANGE_BEGIN)
+      end
+    end
+
+    def self.select_element(element)
+      selection(element, :line, RANGE_BEGIN, last_in(element), :line, RANGE_END)
+    end
+
+    def self.select_key(element)
+      selection(element, :key, RANGE_BEGIN, RANGE_END)
+    end
+
+    def self.select_line(element)
+      selection(element, :line, RANGE_BEGIN, RANGE_END)
+    end
+
+    def self.select_template(element)
+      selection(element, :template, RANGE_BEGIN, RANGE_END)
+    end
+  end
+end