enolib 0.5.0

data/lib/enolib/register.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# TODO: Safe-guard against conflicting loader names (e.g. previous definition or native library function conflict)
+
+module Enolib
+  def self.register(definitions)
+    definitions.each do |name, loader|
+      ElementBase.send(:define_method, "#{name}_key") { key(loader) }
+      ElementBase.send(:define_method, "optional_#{name}_comment") { optional_comment(loader) }
+      ElementBase.send(:define_method, "required_#{name}_comment") { required_comment(loader) }
+      ValueElementBase.send(:define_method, "optional_#{name}_value") { optional_value(loader) }
+      ValueElementBase.send(:define_method, "required_#{name}_value") { required_value(loader) }
+      List.send(:define_method, "optional_#{name}_values") { optional_values(loader) }
+      List.send(:define_method, "required_#{name}_values") { required_values(loader) }
+      MissingElementBase.send(:alias_method, "#{name}_key", :string_key)
+      MissingElementBase.send(:alias_method, "optional_#{name}_comment", :optional_string_comment)
+      MissingElementBase.send(:alias_method, "required_#{name}_comment", :required_string_comment)
+      MissingValueElementBase.send(:alias_method, "optional_#{name}_value", :optional_string_value)
+      MissingValueElementBase.send(:alias_method, "required_#{name}_value", :required_string_value)
+      MissingList.send(:alias_method, "optional_#{name}_values", :optional_string_values)
+      MissingList.send(:alias_method, "required_#{name}_values", :required_string_values)
+    end
+  end
+end

data/lib/enolib/reporters/html_reporter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Enolib
+  class HtmlReporter < Reporter
+    def self.report(context, emphasized = [], marked = [])
+      emphasized = [emphasized] unless emphasized.is_a?(Array)
+      marked = [marked] unless marked.is_a?(Array)
+
+      content_header = context.messages::CONTENT_HEADER
+      gutter_header = context.messages::GUTTER_HEADER
+      omission = line('...', '...')
+
+      snippet = '<pre class="eno-report">'
+
+      snippet += "<div>#{context.sourceLabel}</div>" if context.source
+      snippet += line(gutter_header, content_header)
+
+      in_omission = false
+
+      context[:instructions].each do |instruction|
+        emphasize = emphasized.include?(instruction)
+        mark = marked.include?(instruction)
+
+        show = (emphasized + marked).any? do |marked_instruction|
+          instruction[:line] >= marked_instruction[:line] - 2 &&
+          instruction[:line] <= marked_instruction[:line] + 2
+        end
+
+        if show
+          classes = []
+
+          if emphasize
+            classes.push('eno-report-line-emphasized')
+          elsif mark
+            classes.push('eno-report-line-marked')
+          end
+
+          snippet += line(
+            (instruction[:line] + Enolib::HUMAN_INDEXING).to_s,
+            context[:input][instruction[:index], instruction[:length]],
+            classes
+          )
+
+          in_omission = false
+        elsif !in_omission
+          snippet += omission
+          in_omission = true
+        end
+      end
+
+      snippet += '</pre>'
+
+      snippet
+    end
+
+    private
+
+    def print_line(line, tag)
+      return markup('...', '...') if tag == :omission
+
+      number = (line + HUMAN_INDEXING).to_s
+      instruction = @index[line]
+
+      content = ''
+      if instruction
+        content = @context.input[instruction[:ranges][:line][RANGE_BEGIN]..instruction[:ranges][:line][RANGE_END]]
+      end
+
+      tag_class =
+        case tag
+        when :emphasize
+          'eno-report-line-emphasized'
+        when :indicate
+          'eno-report-line-indicated'
+        when :question
+          'eno-report-line-questioned'
+        else
+          ''
+        end
+
+      markup(number, content, tag_class)
+    end
+
+    def escape(string)
+      string.gsub(/[&<>"'\/]/) { |c| HTML_ESCAPE[c] }
+    end
+
+    def markup(gutter, content, tag_class = '')
+       "<div class=\"eno-report-line #{tag_class}\">" +
+       "<div class=\"eno-report-gutter\">#{gutter.rjust(10)}</div>" +
+       "<div class=\"eno-report-content\">#{escape(content)}</div>" +
+       '</div>'
+    end
+
+    def print
+      columns_header = markup(@context.messages::GUTTER_HEADER, @context.messages::CONTENT_HEADER)
+      snippet = @snippet.each_with_index.map { |tag, line| print_line(line, tag) if tag }.compact.join("\n")
+
+      if @context.source
+        return "<div><div>#{@context.source}</div><pre class=\"eno-report\">#{columns_header}#{snippet}</pre></div>"
+      end
+
+      "<pre class=\"eno-report\">#{columns_header}#{snippet}</pre>"
+    end
+
+    HTML_ESCAPE = {
+      '&' => '&amp;',
+      '<' => '&lt;',
+      '>' => '&gt;',
+      '"' => '&quot;',
+      "'" => '&#39;',
+      '/' => '&#x2F;'
+    }.freeze
+  end
+end

data/lib/enolib/reporters/reporter.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Reporter
+    def initialize(context)
+      @context = context
+      @index = Array.new(@context.line_count)
+      @snippet = Array.new(@context.line_count)
+
+      build_index
+    end
+
+    def indicate_line(element)
+      @snippet[element[:line]] = :indicate
+      self
+    end
+
+    def question_line(element)
+      @snippet[element[:line]] = :question
+      self
+    end
+
+    def report_comments(element)
+      @snippet[element[:line]] = :indicate
+      element[:comments].each do |comment|
+        @snippet[comment[:line]] = :emphasize
+      end
+
+      self
+    end
+
+    def report_element(element)
+      @snippet[element[:line]] = :emphasize
+      tag_element(element, :indicate)
+
+      self
+    end
+
+    def report_elements(elements)
+      elements.each do |element|
+        @snippet[element[:line]] = :emphasize
+        tag_element(element, :indicate)
+      end
+
+      self
+    end
+
+    def report_line(instruction)
+      @snippet[instruction[:line]] = :emphasize
+
+      self
+    end
+
+    def report_multiline_value(element)
+      element[:lines].each do |line|
+        @snippet[line[:line]] = :emphasize
+      end
+
+      self
+    end
+
+    def report_missing_element(parent)
+      @snippet[parent[:line]] = :indicate unless parent[:type] == :document
+
+      if parent[:type] == :section
+        tag_section(parent, :question, false)
+      else
+        tag_element(parent, :question)
+      end
+
+      self
+    end
+
+    def snippet
+      if @snippet.none?
+        (0...@snippet.length).each do |line|
+          @snippet[line] = :question
+        end
+      else
+        # TODO: Possibly better algorithm for this
+        @snippet.each_with_index do |tag, line|
+          next if tag
+
+          if line + 2 < @context.line_count && @snippet[line + 2] && @snippet[line + 2] != :display ||
+             line - 2 > 0 && @snippet[line - 2] && @snippet[line - 2] != :display ||
+             line + 1 < @context.line_count && @snippet[line + 1] && @snippet[line + 1] != :display ||
+             line - 1 > 0 && @snippet[line - 1] && @snippet[line - 1] != :display
+            @snippet[line] = :display
+          elsif line + 3 < @context.line_count && @snippet[line + 3] && @snippet[line + 3] != :display
+            @snippet[line] = :omission
+          end
+        end
+
+        @snippet[-1] = :omission unless @snippet[-1]
+      end
+
+      print
+    end
+
+    private
+
+    def index_comments(element)
+      return unless element.has_key?(:comments)
+
+      element[:comments].each do |comment|
+        @index[comment[:line]] = comment
+      end
+    end
+
+    def traverse(section)
+      section[:elements].each do |element|
+        index_comments(element)
+
+        @index[element[:line]] = element
+
+        if element[:type] == :section
+          traverse(element)
+        elsif element[:type] == :field
+          if element.has_key?(:continuations)
+            element[:continuations].each do |continuation|
+              @index[continuation[:line]] = continuation
+            end
+          end
+        elsif element[:type] == :multiline_field_begin
+          # Missing when reporting an unterminated multiline field
+          if element.has_key?(:end)
+            @index[element[:end][:line]] = element[:end]
+          end
+
+          if element.has_key?(:lines)
+            element[:lines].each do |line|
+              @index[line[:line]] = line
+            end
+          end
+        elsif element[:type] == :list
+          if element.has_key?(:items)
+            element[:items].each do |item|
+              index_comments(item)
+
+              @index[item[:line]] = item
+
+              if item.has_key?(:continuations)
+                item[:continuations].each do |continuation|
+                  @index[continuation[:line]] = continuation
+                end
+              end
+            end
+          end
+        elsif element[:type] == :fieldset
+          if element.has_key?(:entries)
+            element[:entries].each do |entry|
+              index_comments(entry)
+
+              @index[entry[:line]] = entry
+
+              if entry.has_key?(:continuations)
+                entry[:continuations].each do |continuation|
+                  @index[continuation[:line]] = continuation
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def build_index
+      traverse(@context.document)
+
+      @context.meta.each do |instruction|
+        @index[instruction[:line]] = instruction
+      end
+    end
+
+    def tag_continuations(element, tag)
+      scan_line = element[:line] + 1
+
+      return scan_line unless element.has_key?(:continuations)
+
+      element[:continuations].each do |continuation|
+        while scan_line < continuation[:line]
+          @snippet[scan_line] = tag
+          scan_line += 1
+        end
+
+        @snippet[continuation[:line]] = tag
+        scan_line += 1
+      end
+
+      scan_line
+    end
+
+    def tag_continuables(element, collection, tag)
+      scan_line = element[:line] + 1
+
+      return scan_line unless element.has_key?(collection)
+
+      element[collection].each do |continuable|
+        while scan_line < continuable[:line]
+          @snippet[scan_line] = tag
+          scan_line += 1
+        end
+
+        @snippet[continuable[:line]] = tag
+
+        scan_line = tag_continuations(continuable, tag)
+      end
+
+      scan_line
+    end
+
+    def tag_element(element, tag)
+      if element[:type] == :field || element[:type] == :list_item || element[:type] == :fieldset_entry
+        return tag_continuations(element, tag)
+      elsif element[:type] == :list
+        return tag_continuables(element, :items, tag)
+      elsif element[:type] == :fieldset && element.has_key?(:entries)
+        return tag_continuables(element, :entries, tag)
+      elsif element[:type] == :multiline_field_begin
+        if element.has_key?(:lines)
+          element[:lines].each do |line|
+            @snippet[line[:line]] = tag
+          end
+        end
+
+        if element.has_key?(:end)
+          @snippet[element[:end][:line]] = tag
+          return element[:end][:line] + 1
+        elsif element.has_key?(:lines)
+          return element[:lines][-1][:line] + 1
+        else
+          return element[:line] + 1
+        end
+      elsif element[:type] == :section
+        return tag_section(element, tag)
+      end
+    end
+
+    def tag_section(section, tag, recursive=true)
+      scan_line = section[:line] + 1
+
+      section[:elements].each do |element|
+        while scan_line < element[:line]
+          @snippet[scan_line] = :indicate
+          scan_line += 1
+        end
+
+        break if element[:type] == :section && !recursive
+
+        @snippet[element[:line]] = :indicate
+
+        scan_line = tag_element(element, tag)
+      end
+
+      scan_line
+    end
+  end
+end

data/lib/enolib/reporters/terminal_reporter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RESET = "\x1b[0m"
+BOLD = "\x1b[1m"
+DIM = "\x1b[2m"
+
+BLACK = "\x1b[30m"
+BRIGHT_BLACK = "\x1b[90m"
+WHITE = "\x1b[37m"
+BRIGHT_WHITE = "\x1b[97m"
+
+BRIGHT_BLACK_BACKGROUND = "\x1b[40m"
+BRIGHT_RED_BACKGROUND = "\x1b[101m"
+WHITE_BACKGROUND = "\x1b[47m"
+
+INDICATORS = {
+  display: ' ',
+  emphasize: '>',
+  indicate: '*',
+  question: '?'
+}
+
+GUTTER_STYLE = {
+  display: BRIGHT_BLACK_BACKGROUND,
+  emphasize: BLACK + BRIGHT_RED_BACKGROUND,
+  indicate: BLACK + WHITE_BACKGROUND,
+  question: BLACK + WHITE_BACKGROUND
+}
+
+RANGE_STYLE = {
+  'element_operator': WHITE,
+  'escape_begin_operator': WHITE,
+  'escape_end_operator': WHITE,
+  'item_operator': WHITE,
+  'entry_operator': WHITE,
+  'section_operator': WHITE,
+  'copy_operator': WHITE,
+  'deepCopy_operator': WHITE,
+  'multiline_field_operator': WHITE,
+  'direct_line_continuation_operator': WHITE,
+  'spaced_line_continuation_operator': WHITE,
+  'key': BOLD + BRIGHT_WHITE,
+  'template': BOLD + BRIGHT_WHITE,
+  'value': DIM + WHITE
+}
+
+module Enolib
+  class TerminalReporter < Reporter
+    def initialize(context)
+      super(context)
+
+      highest_shown_line_number = @snippet.length
+
+      @snippet.reverse.each_with_index do |tag, index|
+        if tag && tag != :omission
+          highest_shown_line_number = index + 1
+          break
+        end
+      end
+
+      @line_number_padding = [4, highest_shown_line_number.to_s.length].max
+      @header = ''
+
+      if @context.source
+        @header += "#{BLACK + BRIGHT_RED_BACKGROUND} #{INDICATORS[EMPHASIZE]} #{' '.rjust(@line_number_padding)} #{RESET} #{BOLD}#{@context.source}#{RESET}\n"
+      end
+    end
+
+    def print_line(line, tag)
+      if tag == :omission
+        return "#{DIM + BRIGHT_BLACK_BACKGROUND}#{'...'.rjust(@line_number_padding + 2)}  #{RESET}"
+      end
+
+      number = (line + HUMAN_INDEXING).to_s
+      instruction = @index[line]
+
+      content = ''
+      if instruction
+        if instruction[:type] == :comment or instruction[:type] == :unparsed
+          content = BRIGHT_BLACK + @context.input[instruction[:ranges][:line][RANGE_BEGIN]...instruction[:ranges][:line][RANGE_END]] + RESET
+        else
+          content = @context.input[instruction[:ranges][:line][RANGE_BEGIN]...instruction[:ranges][:line][RANGE_END]]
+
+          instruction[:ranges].sort_by { |type, range| range[0] }.reverse_each do |type, range|
+            next if type == :line
+
+            before = content[0...range[RANGE_BEGIN] - instruction[:ranges][:line][RANGE_BEGIN]]
+            after = content[range[RANGE_END] - instruction[:ranges][:line][RANGE_BEGIN]..-1]
+
+            # TODO: Here and everywhere: Why is RANGE_BEGIN without anything and like that even working? Check soundness
+            content = before + RANGE_STYLE[type] + @context.input[range[RANGE_BEGIN]...range[RANGE_END]] + RESET + after
+          end
+        end
+      end
+
+      "#{GUTTER_STYLE[tag]} #{INDICATORS[tag]} #{number.rjust(@line_number_padding)} #{RESET} #{content}"
+    end
+
+    private
+
+    def print
+      snippet = @snippet.each_with_index.map { |tag, line| print_line(line, tag) if tag }.compact.join("\n")
+
+      @header + snippet
+    end
+  end
+end