enolib 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8aeeb10368acccea0f1381c34c6101a552493aea19ef50d8bdc7616f9a898cc7
+  data.tar.gz: 576efc4e4191c945a4d262789e2d353d3521d712b63d1ce4236937d7a556e387
+SHA512:
+  metadata.gz: a37196b8d2b69595e22f68b2b9025f64ec01028442ceddf4d6181cea71903f570561d0c2487d515bbad98ecde76c912284be282f8b3c54590cd026c716c8da33
+  data.tar.gz: e9c8143539d6eb1fbf7a6e594208a70d5d6cad25f77d471556b1091d7bd4b3cfd268dbb28a0b764cbc0701b01184bd428cedfd6aecea24bac9d9c222ec8873f6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Simon Repp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# enolib
+
+The cross-language eno standard library
+
+## Installation
+
+### Bundler
+
+Add `enolib` to your `Gemfile`:
+
+```ruby
+gem 'enolib'
+```
+Then let bundler install it for you:
+
+```
+bundle
+```
+
+### Manually
+
+Alternatively you can also install it manually:
+
+```
+gem install enolib
+```
+
+## Getting started
+
+A minimal example to read an eno document directly from a string with `enolib`:
+
+```ruby
+require 'enolib'
+
+document = Enolib.parse('Greeting: Hello World!')
+
+puts document.field('Greeting').required_string_value  #=> 'Hello World!'
+```
+
+## Documentation
+
+Until available please use the javascript or python documentation at [eno-lang.org/enolib](https://eno-lang.org/enolib/) and replace all shown syntax with the ruby equivalent (ie. different case for the most part) - except for language specifics the API is exactly the same for all implementations.
+
+## Beta notice
+
+enolib is currently in beta, if you encounter any issues please report them in the issue tracker - thank you for your help!
+
+## Compatibility notice
+
+enolib supports the not yet completely ratified [final specification](https://github.com/eno-lang/eno/tree/master/rfcs-final-spec) for eno. You are encouraged to use it in your projects already, thereby helping us to gather insights on whether there are any remaining flaws in the proposed final specifications (you're very welcome to report such issues if you encounter them).
+
+From a practical point of view there are not likely any major changes ahead.  Unless you build your application around edge cases of the exotic language features you should be perfectly safe and future-proof.

data/lib/enolib.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'enolib/constants'
+require 'enolib/context'
+require 'enolib/errors'
+require 'enolib/grammar_regexp'
+require 'enolib/messages/en'
+require 'enolib/lookup'
+require 'enolib/parse'
+require 'enolib/parser'
+require 'enolib/register'
+
+require 'enolib/elements/element_base'
+require 'enolib/elements/value_element_base'
+require 'enolib/elements/section_element'
+require 'enolib/elements/element'
+require 'enolib/elements/empty'
+require 'enolib/elements/field'
+require 'enolib/elements/fieldset_entry'
+require 'enolib/elements/fieldset'
+require 'enolib/elements/list_item'
+require 'enolib/elements/list'
+require 'enolib/elements/section'
+
+require 'enolib/elements/missing/missing_element_base'
+require 'enolib/elements/missing/missing_value_element_base'
+require 'enolib/elements/missing/missing_empty'
+require 'enolib/elements/missing/missing_field'
+require 'enolib/elements/missing/missing_fieldset'
+require 'enolib/elements/missing/missing_fieldset_entry'
+require 'enolib/elements/missing/missing_list'
+require 'enolib/elements/missing/missing_section'
+require 'enolib/elements/missing/missing_section_element'
+
+require 'enolib/errors/selections'
+require 'enolib/errors/parsing'
+require 'enolib/errors/validation'
+
+require 'enolib/reporters/reporter'
+require 'enolib/reporters/html_reporter'
+require 'enolib/reporters/terminal_reporter'
+require 'enolib/reporters/text_reporter'

data/lib/enolib/constants.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Enolib
+  HUMAN_INDEXING = 1
+  PRETTY_TYPES = {
+    document: 'document',
+    empty_element: 'empty_element',
+    field: 'field',
+    fieldset: 'fieldset',
+    fieldset_entry: 'fieldset_entry',
+    list: 'list',
+    list_item: 'list_item',
+    multiline_field_begin: 'field',
+    section: 'section'
+  }
+end

data/lib/enolib/context.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Context
+    attr_accessor :document, :input, :line_count, :messages, :meta, :reporter, :source
+
+    def initialize(input, locale: Messages::En, reporter: TextReporter, source: nil)
+      @input = input
+      @messages = locale
+      @reporter = reporter
+      @source = source
+
+      @document = {
+        elements: [],
+        type: :document
+      }
+
+      @meta = []
+
+      Parser.new(self).run
+    end
+
+    def comment(element)
+      unless element.has_key?(:computed_comment)
+        element[:computed_comment] =
+          if !element.has_key?(:comments)
+            nil
+          elsif element[:comments].length == 1
+            element[:comments].first[:comment]
+          else
+            first_non_empty_line_index = nil
+            last_non_empty_line_index = nil
+            shared_indent = Float::INFINITY
+
+            element[:comments].each_with_index do |comment, index|
+              if comment.has_key?(:comment)
+                first_non_empty_line_index = index unless first_non_empty_line_index
+                last_non_empty_line_index = index
+
+                indent = comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]
+                shared_indent = indent if indent < shared_indent
+              end
+            end
+
+            if first_non_empty_line_index
+                non_empty_lines = element[:comments][first_non_empty_line_index..last_non_empty_line_index]
+
+                non_empty_lines.map do |comment|
+                  if !comment.has_key?(:comment)
+                    ''
+                  elsif (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN]) == shared_indent
+                    comment[:comment]
+                  else
+                    (' ' * (comment[:ranges][:comment][RANGE_BEGIN] - comment[:ranges][:line][RANGE_BEGIN] - shared_indent)) + comment[:comment]
+                  end
+                end.join("\n")
+            else
+              nil
+            end
+          end
+      end
+
+      element[:computed_comment]
+    end
+
+    def elements(section)
+      return elements(section[:mirror]) if section.has_key?(:mirror)
+
+      unless section.has_key?(:computed_elements)
+        section[:computed_elements] = section[:elements]
+        section[:computed_elements_map] = {}
+
+        section[:computed_elements].each do |element|
+          if section[:computed_elements_map].has_key?(element[:key])
+            section[:computed_elements_map][element[:key]].push(element)
+          else
+            section[:computed_elements_map][element[:key]] = [element]
+          end
+        end
+
+        if section.has_key?(:extend)
+          copied_elements = elements(section[:extend]).reject { |element| section[:computed_elements_map].has_key?(element[:key]) }
+
+          section[:computed_elements] = copied_elements + section[:computed_elements]
+
+          copied_elements.each do |element|
+            if section[:computed_elements_map].has_key?(element[:key])
+              section[:computed_elements_map][element[:key]].push(element)
+            else
+              section[:computed_elements_map][element[:key]] = [element]
+            end
+          end
+        end
+      end
+
+      section[:computed_elements]
+    end
+
+    def entries(fieldset)
+      return entries(fieldset[:mirror]) if fieldset.has_key?(:mirror)
+
+      unless fieldset.has_key?(:computed_entries)
+        fieldset[:computed_entries] = fieldset[:entries]
+        fieldset[:computed_entries_map] = {}
+
+        fieldset[:computed_entries].each do |entry|
+          if fieldset[:computed_entries_map].has_key?(entry[:key])
+            fieldset[:computed_entries_map][entry[:key]].push(entry)
+          else
+            fieldset[:computed_entries_map][entry[:key]] = [entry]
+          end
+        end
+
+        if fieldset.has_key?(:extend)
+          copied_entries = entries(fieldset[:extend]).reject { |entry| fieldset[:computed_entries_map].has_key?(entry[:key]) }
+
+          fieldset[:computed_entries] = copied_entries + fieldset[:computed_entries]
+
+          copied_entries.each do |entry|
+            if fieldset[:computed_entries_map].has_key?(entry[:key])
+              fieldset[:computed_entries_map][entry[:key]].push(entry)
+            else
+              fieldset[:computed_entries_map][entry[:key]] = [entry]
+            end
+          end
+        end
+      end
+
+      fieldset[:computed_entries]
+    end
+
+    def items(list)
+      if list.has_key?(:mirror)
+        items(list[:mirror])
+      elsif list.has_key?(:extend)
+        items(list[:extend]) + list[:items]
+      elsif list.has_key?(:items)
+        list[:items]
+      else
+        []
+      end
+    end
+
+    def raw(element)
+      # TODO: In other implementations there is only one 'field' type
+      #       here we get a) symbols, b) including :multiline_field_begin
+      result = { type: element[:type] }
+
+      # TODO: Revisit to think through the case of a present but empty comment
+      result[:comment] = comment(element) if element.has_key?(:comments)
+
+      case element[:type]
+      when :empty_element
+        result[:key] = element[:key]
+      when :field
+        result[:key] = element[:key]
+        result[:value] = value(element)
+      when :list_item
+        result[:value] = value(element)
+      when :fieldset_entry
+        result[:key] = element[:key]
+        result[:value] = value(element)
+      when :multiline_field_begin
+        result[:key] = element[:key]
+        result[:value] = value(element)
+      when :list
+        result[:key] = element[:key]
+        result[:items] = items(element).map { |item| raw(item) }
+      when :fieldset
+        result[:key] = element[:key]
+        result[:entries] = entries(element).map { |entry| raw(entry) }
+      when :section
+        result[:key] = element[:key]
+        result[:elements] = elements(element).map { |section_element| raw(section_element) }
+      when :document
+        result[:elements] = elements(element).map { |section_element| raw(section_element) }
+      end
+
+      result
+    end
+
+    def value(element)
+      unless element.has_key?(:computed_value)
+        return value(element[:mirror]) if element.has_key?(:mirror)
+
+        element[:computed_value] = nil
+
+        if element[:type] == :multiline_field_begin
+          if element.has_key?(:lines)
+            element[:computed_value] = @input[
+              element[:lines][0][:ranges][:line][0]...element[:lines][-1][:ranges][:line][1]
+            ]
+          end
+        else
+          element[:computed_value] = element[:value] if element.has_key?(:value)
+
+          if element.has_key?(:continuations)
+            unapplied_spacing = nil
+
+            element[:continuations].each do |continuation|
+              if element[:computed_value] == nil
+                element[:computed_value] = continuation[:value] if continuation.has_key?(:value)
+                unapplied_spacing = nil
+              elsif !continuation.has_key?(:value)
+                unapplied_spacing ||= continuation.has_key?(:spaced)
+              elsif continuation.has_key?(:spaced) || unapplied_spacing
+                element[:computed_value] += ' ' + continuation[:value]
+                unapplied_spacing = nil
+              else
+                element[:computed_value] += continuation[:value]
+              end
+            end
+          end
+        end
+      end
+
+      return element[:computed_value]
+    end
+  end
+end

data/lib/enolib/elements/element.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Enolib
+  class Element < SectionElement
+    def to_fieldset_entry
+      unless instance_variable_defined?(:@fieldset_entry)
+        unless @instruction[:type] == :fieldset_entry
+          # TODO: Below and in all implementations - why nil for key as second parameter?
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_fieldset_entry')
+        end
+
+        @fieldset_entry = FieldsetEntry.new(@context, @instruction)
+      end
+
+      @fieldset_entry
+    end
+
+    def to_list_item
+      unless instance_variable_defined?(:@list_item)
+        unless @instruction[:type] == :list_item
+          raise Errors::Validation.unexpected_element_type(@context, nil, @instruction, 'expected_list_item')
+        end
+
+        @list_item = FieldsetEntry.new(@context, @instruction)
+      end
+
+      @list_item
+    end
+
+    def yields_fieldset_entry?
+      @instruction[:type] == :fieldset_entry
+    end
+
+    def yields_list_item?
+      @instruction[:type] == :list_item
+    end
+
+    def to_s
+      "#<Enolib::Element key=#{@instruction[:key]}>"
+    end
+  end
+end

data/lib/enolib/elements/element_base.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Enolib
+  class ElementBase
+    def initialize(context, instruction, parent = nil)
+      @context = context
+      @instruction = instruction
+      @parent = parent
+    end
+
+    def comment_error(message = nil)
+      if block_given?
+        message = yield(@context.comment(@instruction))
+      elsif message.is_a?(Proc)
+        message = message.call(@context.comment(@instruction))
+      end
+
+      unless message
+        raise ArgumentError.new('A message or message function must be provided')
+      end
+
+      Errors::Validation.comment_error(@context, message, @instruction)
+    end
+
+    def error(message = nil)
+      if block_given?
+        message = yield(self)  # Revisit self in this context - problematic
+      elsif message.is_a?(Proc)
+        message = message.call(self)  # Revisit self in this context - problematic
+      end
+
+      unless message
+        raise ArgumentError.new('A message or message function must be provided')
+      end
+
+      Errors::Validation.element_error(@context, message, @instruction)
+    end
+
+    def key(loader = nil)
+      loader = Proc.new if block_given?
+
+      @touched = true
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      begin
+        loader.call(_key)
+      rescue => message
+        raise Errors::Validation.key_error(@context, message, @instruction)
+      end
+    end
+
+    def key_error(message = nil)
+      if block_given?
+        message = yield(_key)
+      elsif message.is_a?(Proc)
+        message = message.call(_key)
+      end
+
+      unless message
+        raise ArgumentError.new('A message or message function must be provided')
+      end
+
+      Errors::Validation.key_error(@context, message, @instruction)
+    end
+
+    def optional_comment(loader = nil)
+      loader = Proc.new if block_given?
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _comment(loader, required: false)
+    end
+
+    def optional_string_comment()
+      _comment(required: false)
+    end
+
+    def raw
+      @context.raw(@instruction)
+    end
+
+    def required_comment(loader = nil)
+      loader = Proc.new if block_given?
+
+      unless loader
+        raise ArgumentError.new('A loader function must be provided')
+      end
+
+      _comment(loader, required: true)
+    end
+
+    def required_string_comment()
+      _comment(required: true)
+    end
+
+    def string_key
+      @touched = true
+
+      _key
+    end
+
+    def touch
+      @touched = true
+    end
+
+    private
+
+    def _comment(loader = nil, required:)
+      @touched = true
+
+      comment = @context.comment(@instruction)
+
+      if comment
+        return comment unless loader
+
+        begin
+          loader.call(comment)
+        rescue => message
+          raise Errors::Validation.comment_error(@context, message, @instruction)
+        end
+      else
+        return nil unless required
+
+        raise Errors::Validation.missing_comment(@context, @instruction)
+      end
+    end
+
+    def _key
+      if @instruction[:type] == :list_item
+        @instruction[:parent][:key]
+      else
+        @instruction[:key]
+      end
+    end
+  end
+end