enolib 0.5.0

data/lib/enolib/errors/validation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Enolib
+  module Errors
+    module Validation
+      def self.comment_error(context, message, element)
+        ValidationError.new(
+          context.messages.comment_error(message),
+          context.reporter.new(context).report_comments(element).snippet(),
+          Selections::select_comments(element)
+        )
+      end
+
+      def self.element_error(context, message, element)
+        ValidationError.new(
+          message,
+          context.reporter.new(context).report_element(element).snippet(),
+          Selections::select_element(element)
+        )
+      end
+
+      def self.key_error(context, message, element)
+        ValidationError.new(
+          context.messages.key_error(message),
+          context.reporter.new(context).report_line(element).snippet(),
+          Selections::select_key(element)
+        )
+      end
+
+      def self.missing_comment(context, element)
+        ValidationError.new(
+          context.messages::MISSING_COMMENT,
+          context.reporter.new(context).report_line(element).snippet(), # TODO: Question-tag an empty line before an element with missing comment
+          Selections::selection(element, :line, RANGE_BEGIN)
+        )
+      end
+
+      def self.missing_element(context, key, parent, message)
+        ValidationError.new(
+          key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
+          context.reporter.new(context).report_missing_element(parent).snippet(),
+          parent[:type] == :document ? Selections::DOCUMENT_BEGIN : Selections::selection(parent, :line, RANGE_END)
+        )
+      end
+
+      def self.missing_value(context, element)
+        selection = {}
+
+        if element[:type] == :field ||
+           element[:type] == :empty_element ||
+           element[:type] == :multiline_field_begin
+          message = context.messages.missing_field_value(element[:key])
+
+          if element[:ranges].has_key?(:template)
+            selection[:from] = Selections::cursor(element, :template, RANGE_END)
+          elsif element[:ranges].has_key?(:element_operator)
+            selection[:from] = Selections::cursor(element, :element_operator, RANGE_END)
+          else
+            selection[:from] = Selections::cursor(element, :line, RANGE_END)
+          end
+        elsif element[:type] == :fieldset_entry
+          message = context.messages.missing_fieldset_entry_value(element[:key])
+          selection[:from] = Selections::cursor(element, :entry_operator, RANGE_END)
+        elsif element[:type] == :list_item
+          message = context.messages.missing_list_item_value(element[:parent][:key])
+          selection[:from] = Selections::cursor(element, :item_operator, RANGE_END)
+        end
+
+        snippet = context.reporter.new(context).report_element(element).snippet()
+
+        if element[:type] == :field and element.has_key?(:continuations)
+          selection[:to] = Selections::cursor(element[:continuations].last, :line, RANGE_END)
+        else
+          selection[:to] = Selections::cursor(element, :line, RANGE_END)
+        end
+
+        ValidationError.new(message, snippet, selection)
+      end
+
+      def self.unexpected_element(context, message, element)
+        ValidationError.new(
+          message || context.messages::UNEXPECTED_ELEMENT,
+          context.reporter.new(context).report_element(element).snippet(),
+          Selections::select_element(element)
+        )
+      end
+
+      def self.unexpected_multiple_elements(context, key, elements, message)
+        ValidationError.new(
+          key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
+          context.reporter.new(context).report_elements(elements).snippet(),
+          Selections::select_element(elements[0])
+        )
+      end
+
+      def self.unexpected_element_type(context, key, section, message)
+        ValidationError.new(
+          key ? context.messages.send(message + '_with_key', key) : context.messages.const_get(message.upcase), # TODO: Solve the upcase rather through a different generated message type, e.g. method instead of constant
+          context.reporter.new(context).report_element(section).snippet(),
+          Selections::select_element(section)
+        )
+      end
+
+      def self.value_error(context, message, element)
+        if element.has_key?(:mirror)
+          snippet = context.reporter.new(context).report_line(element).snippet()
+          select = select_key(element)
+        elsif element[:type] == :multiline_field_begin
+          if element.has_key?(:lines)
+            snippet = context.reporter.new(context).report_multiline_value(element).snippet()
+            select = Selections::selection(element[:lines][0], :line, RANGE_BEGIN, element[:lines][-1], :line, RANGE_END)
+          else
+            snippet = context.reporter.new(context).report_element(element).snippet()
+            select = Selections::selection(element, :line, RANGE_END)
+          end
+        else
+          snippet = context.reporter.new(context).report_element(element).snippet()
+          select = {}
+
+          if element[:ranges].has_key?(:value)
+            select[:from] = Selections::cursor(element, :value, RANGE_BEGIN)
+          elsif element[:ranges].has_key?(:element_operator)
+            select[:from] = Selections::cursor(element, :element_operator, RANGE_END)
+          elsif element[:ranges].has_key?(:entry_operator)
+            select[:from] = Selections::cursor(element, :entry_operator, RANGE_END)
+          elsif element[:type] == :list_item
+            select[:from] = Selections::cursor(element, :item_operator, RANGE_END)
+          else
+            # TODO: Possibly never reached - think through state permutations
+            select[:from] = Selections::cursor(element, :line, RANGE_END)
+          end
+
+          if element.has_key?(:continuations)
+            select[:to] = Selections::cursor(element[:continuations][-1], :line, RANGE_END)
+          elsif element[:ranges].has_key?(:value)
+            select[:to] = Selections::cursor(element, :value, RANGE_END)
+          else
+            select[:to] = Selections::cursor(element, :line, RANGE_END)
+          end
+        end
+
+        ValidationError.new(context.messages.value_error(message), snippet, select)
+      end
+    end
+  end
+end

data/lib/enolib/grammar_regexp.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Note: Study this file from the bottom up
+
+# TODO: Try out possesive quantifiers (careful x{2,}+ does not work in ruby, only xx++ (!)) - benchmark?
+
+module Enolib
+  module Grammar
+    OPTIONAL = /([^\n]+?)?/.source
+    REQUIRED = /(\S[^\n]*?)/.source
+
+    #
+    EMPTY = /()/.source
+    EMPTY_LINE_INDEX = 1
+
+    # | value
+    DIRECT_LINE_CONTINUATION = /(\|)[^\S\n]*#{OPTIONAL}/.source
+    DIRECT_LINE_CONTINUATION_OPERATOR_INDEX = 2
+    DIRECT_LINE_CONTINUATION_VALUE_INDEX = 3
+
+    # \ value
+    SPACED_LINE_CONTINUATION = /(\\)[^\S\n]*#{OPTIONAL}/.source
+    SPACED_LINE_CONTINUATION_OPERATOR_INDEX = 4
+    SPACED_LINE_CONTINUATION_VALUE_INDEX = 5
+
+    CONTINUATION = /#{DIRECT_LINE_CONTINUATION}|#{SPACED_LINE_CONTINUATION}/.source
+
+    # > Comment
+    COMMENT = /(>)[^\S\n]*#{OPTIONAL}/.source
+    COMMENT_OPERATOR_INDEX = 6
+    COMMENT_VALUE_INDEX = 7
+
+    # - value
+    LIST_ITEM = /(-)(?!-)[^\S\n]*#{OPTIONAL}/.source
+    LIST_ITEM_OPERATOR_INDEX = 8
+    LIST_ITEM_VALUE_INDEX = 9
+
+    # -- key
+    MULTILINE_FIELD = /(-{2,})(?!-)[^\S\n]*#{REQUIRED}/.source
+    MULTILINE_FIELD_OPERATOR_INDEX = 10
+    MULTILINE_FIELD_KEY_INDEX = 11
+
+    # #
+    SECTION_OPERATOR = /(#+)(?!#)/.source
+    SECTION_OPERATOR_INDEX = 12
+
+    # # key
+    SECTION_KEY_UNESCAPED = /([^\s`<][^<\n]*?)/.source
+    SECTION_KEY_UNESCAPED_INDEX = 13
+
+    # # `key`
+    SECTION_KEY_ESCAPE_BEGIN_OPERATOR_INDEX = 14
+    SECTION_KEY_ESCAPED = /(`+)(?!`)[^\S\n]*(\S[^\n]*?)[^\S\n]*(#{"\\#{SECTION_KEY_ESCAPE_BEGIN_OPERATOR_INDEX}"})/.source # TODO: Should this exclude the backreference inside the quotes? (as in ((?:(?!\1).)+) ) here and elsewhere (probably not because it's not greedy.?!
+    SECTION_KEY_ESCAPED_INDEX = 15
+    SECTION_KEY_ESCAPE_END_OPERATOR_INDEX = 16
+
+    # # key < template
+    # # `key` < template
+    SECTION_KEY = /(?:#{SECTION_KEY_UNESCAPED}|#{SECTION_KEY_ESCAPED})/.source
+    SECTION_TEMPLATE = /(?:(<(?!<)|<<)[^\S\n]*#{REQUIRED})?/.source
+    SECTION = /#{SECTION_OPERATOR}\s*#{SECTION_KEY}[^\S\n]*#{SECTION_TEMPLATE}/.source
+    SECTION_COPY_OPERATOR_INDEX = 17
+    SECTION_TEMPLATE_INDEX = 18
+
+    EARLY_DETERMINED = /#{CONTINUATION}|#{COMMENT}|#{LIST_ITEM}|#{MULTILINE_FIELD}|#{SECTION}/.source
+
+    # key
+    KEY_UNESCAPED = /([^\s>#\-`\\|:=<][^\n:=<]*?)/.source
+    KEY_UNESCAPED_INDEX = 19
+
+    # `key`
+    KEY_ESCAPE_BEGIN_OPERATOR_INDEX = 20
+    KEY_ESCAPED = /(`+)(?!`)[^\S\n]*(\S[^\n]*?)[^\S\n]*(#{"\\#{KEY_ESCAPE_BEGIN_OPERATOR_INDEX}"})/.source
+    KEY_ESCAPED_INDEX = 21
+    KEY_ESCAPE_END_OPERATOR_INDEX = 22
+
+    KEY = /(?:#{KEY_UNESCAPED}|#{KEY_ESCAPED})/.source
+
+    # :
+    # : value
+    ELEMENT_OR_FIELD = /(:)[^\S\n]*#{OPTIONAL}/.source
+    ELEMENT_OPERATOR_INDEX = 23
+    FIELD_VALUE_INDEX = 24
+
+    # =
+    # = value
+    FIELDSET_ENTRY = /(=)[^\S\n]*#{OPTIONAL}/.source
+    FIELDSET_ENTRY_OPERATOR_INDEX = 25
+    FIELDSET_ENTRY_VALUE_INDEX = 26
+
+    # < template
+    # << template
+    COPY = /(<(?!<)|<<)\s*#{REQUIRED}/.source
+    COPY_OPERATOR_INDEX = 27
+    TEMPLATE_INDEX = 28
+
+    LATE_DETERMINED = /#{KEY}\s*(?:#{ELEMENT_OR_FIELD}|#{FIELDSET_ENTRY}|#{COPY})/.source
+
+    NOT_EMPTY = /(?:#{EARLY_DETERMINED}|#{LATE_DETERMINED})/.source
+
+    REGEX = /[^\S\n]*(?:#{EMPTY}|#{NOT_EMPTY})[^\S\n]*(?=\n|$)/
+  end
+end

data/lib/enolib/lookup.rb

@@ -0,0 +1,235 @@
+RANGE_BEGIN = 0
+RANGE_END = 1
+
+def check_multiline_field_by_line(field, line)
+  return false if line < field[:line] ||
+                  line > field[:end][:line]
+
+  if line == field[:line]
+    { element: field, instruction: field }
+  elsif line == field[:end][:line]
+    { element: field, instruction: field[:end] }
+  else
+    {
+      element: field,
+      instruction: field[:lines].find { |candidate| candidate[:line] == line }
+    }
+  end
+end
+
+def check_multiline_field_by_index(field, index)
+  return false if index < field[:ranges][:line][RANGE_BEGIN] ||
+                  index > field[:end][:ranges][:line][RANGE_END]
+
+  if index <= field[:ranges][:line][RANGE_END]
+    { element: field, instruction: field }
+  elsif index >= field[:end][:ranges][:line][RANGE_BEGIN]
+    { element: field, instruction: field[:end] }
+  else
+    {
+      element: field,
+      instruction: field[:lines].find { |candidate| index <= candidate[:ranges][:line][RANGE_END] }
+    }
+  end
+end
+
+def check_field_by_line(field, line)
+  return false if line < field[:line]
+  return { element: field, instruction: field } if line == field[:line]
+  return false unless field.has_key?(:continuations) &&
+                      line <= field[:continuations].last[:line]
+
+  field[:continuations].each do |continuation|
+    return { element: field, instruction: continuation } if line == continuation[:line]
+    return { element: field, instruction: nil } if line < continuation[:line]
+  end
+end
+
+def check_field_by_index(field, index)
+  return false if index < field[:ranges][:line][RANGE_BEGIN]
+  return { element: field, instruction: field } if index <= field[:ranges][:line][RANGE_END]
+  return false unless field.has_key?(:continuations) &&
+                      index <= field[:continuations].last[:ranges][:line][RANGE_END]
+
+  field[:continuations].each do |continuation|
+    return { element: field, instruction: nil } if index < continuation[:ranges][:line][RANGE_BEGIN]
+    return { element: field, instruction: continuation } if index <= continuation[:ranges][:line][RANGE_END]
+  end
+end
+
+def check_fieldset_by_line(fieldset, line)
+  return false if line < fieldset[:line]
+  return { element: fieldset, instruction: fieldset } if line == fieldset[:line]
+  return false unless fieldset.has_key?(:entries) &&
+                      line <= fieldset[:entries].last[:line]
+
+
+  fieldset[:entries].each do |entry|
+    return { element: entry, instruction: entry } if line == entry[:line]
+    return { element: fieldset, instruction: nil } if line < entry[:line]
+
+    match_in_entry = check_field_by_line(entry, line)
+
+    return match_in_entry if match_in_entry
+  end
+end
+
+def check_fieldset_by_index(fieldset, index)
+  return false if index < fieldset[:ranges][:line][RANGE_BEGIN]
+  return { element: fieldset, instruction: fieldset } if index <= fieldset[:ranges][:line][RANGE_END]
+  return false unless fieldset.has_key?(:entries) &&
+                      index <= fieldset[:entries].last[:ranges][:line][RANGE_END]
+
+  fieldset[:entries].each do |entry|
+    return { element: fieldset, instruction: nil } if index < entry[:ranges][:line][RANGE_BEGIN]
+    return { element: entry, instruction: entry } if index <= entry[:ranges][:line][RANGE_END]
+
+    match_in_entry = check_field_by_index(entry, index)
+
+    return match_in_entry if match_in_entry
+  end
+end
+
+def check_list_by_line(list, line)
+  return false if line < list[:line]
+  return { element: list, instruction: list } if line == list[:line]
+  return false unless list.has_key?(:items) && line > list[:items].last[:line]
+
+  list[:items].each do |item|
+    return { element: item, instruction: item } if line == item[:line]
+    return { element: list, instruction: nil } if line < item[:line]
+
+    match_in_item = check_field_by_line(item, line)
+
+    return match_in_item if match_in_item
+  end
+end
+
+def check_list_by_index(list, index)
+  return false if index < list[:ranges][:line][RANGE_BEGIN]
+  return { element: list, instruction: list } if index <= list[:ranges][:line][RANGE_END]
+  return false unless list.has_key?(:items) &&
+                      index > list[:items].last[:ranges][:line][RANGE_END]
+
+  list[:items].each do |item|
+    return { element: list, instruction: nil } if index < item[:ranges][:line][RANGE_BEGIN]
+    return { element: item, instruction: item } if index <= item[:ranges][:line][RANGE_END]
+
+    match_in_item = check_field_by_index(item, index)
+
+    return match_in_item if match_in_item
+  end
+end
+
+def check_in_section_by_line(section, line)
+  section[:elements].reverse_each do |element|
+    next if element[:line] > line
+
+    return { element: element, instruction: element } if element[:line] == line
+
+    case element[:type]
+    when :field
+      match_in_field = check_field_by_line(element, line)
+      return match_in_field if match_in_field
+    when :fieldset
+      match_in_fieldset = check_fieldset_by_line(element, line)
+      return match_in_fieldset if match_in_fieldset
+    when :list
+      match_in_list = check_list_by_line(element, line)
+      return match_in_list if match_in_list
+    when :multiline_field_begin
+      unless element.has_key?(:template)
+        match_in_multiline_field = check_multiline_field_by_line(element, line)
+        return match_in_multiline_field if match_in_multiline_field
+      end
+    when :section
+      return check_in_section_by_line(element, line)
+    end
+
+    break
+  end
+
+  { element: section, instruction: nil }
+end
+
+def check_in_section_by_index(section, index)
+  section[:elements].reverse_each do |element|
+    next if index < element[:ranges][:line][RANGE_BEGIN]
+
+    return { element: element, instruction: element } if index <= element[:ranges][:line][RANGE_END]
+
+    case element[:type]
+    when :field
+      match_in_field = check_field_by_index(element, index)
+      return match_in_field if match_in_field
+    when :fieldset
+      match_in_fieldset = check_fieldset_by_index(element, index)
+      return match_in_fieldset if match_in_fieldset
+    when :list
+      match_in_list = check_list_by_index(element, index)
+      return match_in_list if match_in_list
+    when :multiline_field_begin
+      unless element.has_key?(:template)
+        match_in_multiline_field = check_multiline_field_by_index(element, index)
+        return match_in_multiline_field if match_in_multiline_field
+      end
+    when :section
+      return check_in_section_by_index(element, index)
+    end
+
+    break
+  end
+
+  { element: section, instruction: nil }
+end
+
+module Enolib
+  def self.lookup(input, column: nil, index: nil, line: nil, **options)
+    context = Context.new(input, **options)
+
+    match = nil
+    if index
+      if index < 0 || index > context.input.length
+        raise IndexError.new("You are trying to look up an index (#{index}) outside of the document's index range (0-#{context.input.length})")
+      end
+
+      match = check_in_section_by_index(context.document, index)
+    else
+      if line < 0 || line >= context.line_count
+        raise IndexError.new("You are trying to look up a line (#{line}) outside of the document's line range (0-#{context.line_count - 1})")
+      end
+
+      match = check_in_section_by_line(context.document, line)
+    end
+
+    result = {
+      element: Element.new(context, match[:element]),
+      range: nil
+    }
+
+    instruction = match[:instruction]
+
+    unless instruction
+      instruction = context.meta.find { |candidate| candidate[:line] == line }
+      return result unless instruction
+    end
+
+    rightmost_match = instruction[:ranges][:line][0]
+
+    unless index
+      index = instruction[:ranges][:line][0] + column
+    end
+
+    instruction[:ranges].each do |type, range|
+      next if type == :line
+
+      if index >= range[RANGE_BEGIN] && index <= range[RANGE_END] && range[RANGE_BEGIN] >= rightmost_match
+        result[:range] = type
+        # TODO: Provide content of range too as convenience
+        rightmost_match = index
+      end
+    end
+
+    result
+  end
+end