nestedtext 0.1.0

data/lib/nestedtext/encode_helpers.rb

@@ -0,0 +1,24 @@
+require "nestedtext/dumper"
+
+module NestedText
+  module NTEncodeStrictMixing
+    def to_nt(indentation: 4, strict: true)
+      Dumper.new(EncodeOptions.new(indentation, strict)).dump self
+    end
+  end
+
+  module NTEncodeMixing
+    def to_nt(indentation: 4)
+      Dumper.new(EncodeOptions.new(indentation, false)).dump self
+    end
+  end
+
+  class EncodeOptions
+    attr_reader :indentation, :strict
+
+    def initialize(indentation = 4, strict = true)
+      @indentation = indentation
+      @strict = strict
+    end
+  end
+end

data/lib/nestedtext/errors.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "word_wrap"
+require "word_wrap/core_ext"
+
+require "nestedtext/constants"
+
+module NestedText
+  # Top level ParseError for clients to rescue.
+  class Error < StandardError; end
+
+  module Errors
+    # TODO: rename all Subclasses to ParseXError, just like for Dump
+    class ParseError < Error
+      attr_reader :lineno, :colno, :message_raw
+
+      def initialize(line, colno, message)
+        # Note, both line and column number are 0-indexed.
+        # But for human display we make them 1-indexed.
+        @lineno = line.lineno
+        @colno = colno
+        @message_raw = message
+        super(pretty_message(line))
+      end
+
+      private
+
+      def pretty_message(line)
+        lineno_disp = @lineno + 1
+        colno_disp = @colno + 1
+        prefix = "\nParse ParseError (line #{lineno_disp}, column #{colno_disp}): "
+
+        last_lines = ""
+        # From one line to another, we can at most have 1 digits length difference.
+        digits = lineno_disp.to_s.length
+        unless line.prev.nil?
+          lline_indent = " " * line.prev.indentation
+          prev_lineno_disp = line.prev.lineno + 1
+          last_lines += "\n\t#{prev_lineno_disp.to_s.rjust(digits)}│#{lline_indent}#{line.prev.content}"
+        end
+        line_indent = " " * line.indentation
+        last_lines += "\n\t#{lineno_disp}│#{line_indent}#{line.content}"
+
+        marker_indent = colno_disp + digits # +1 for the "|"
+        marker = "\n\t" + " " * marker_indent + "^"
+
+        prefix + @message_raw + last_lines + marker
+      end
+    end
+
+    class LineTagUnknown < ParseError
+      def initialize(line, tag)
+        super(line, line.indentation, "The Line tag #{tag} is not among the allowed ones #{Line::ALLOWED_LINE_TAGS}")
+      end
+    end
+
+    class LineTagNotDetected < ParseError
+      def initialize(line)
+        super(line, line.indentation, "unrecognized line.")
+      end
+    end
+
+    class LineTypeExpectedListItem < ParseError
+      def initialize(line)
+        super(line, line.indentation, "expected list item.")
+      end
+    end
+
+    class MultilineKeyNoValue < ParseError
+      def initialize(line)
+        super(line, line.indentation, "multiline key requires a value.")
+      end
+    end
+
+    class InlineDictSyntaxError < ParseError
+      def initialize(line, colno, wrong_char)
+        super(line, line.indentation + colno, "expected ‘,’ or ‘}’, found ‘#{wrong_char}’.")
+      end
+    end
+
+    class InlineDictKeySyntaxError < ParseError
+      def initialize(line, colno, wrong_char)
+        super(line, line.indentation + colno, "expected ‘:’, found ‘#{wrong_char}’.")
+      end
+    end
+
+    class InlineMissingValue < ParseError
+      def initialize(line, colno)
+        super(line, line.indentation + colno, "expected value.")
+      end
+    end
+
+    class InlineListSyntaxError < ParseError
+      def initialize(line, colno, wrong_char)
+        super(line, line.indentation + colno, "expected ‘,’ or ‘]’, found ‘#{wrong_char}’.")
+      end
+    end
+
+    class InlineNoClosingDelimiter < ParseError
+      def initialize(line, colno)
+        super(line, line.indentation + colno, "line ended without closing delimiter.")
+      end
+    end
+
+    class InlineExtraCharactersAfterDelimiter < ParseError
+      def initialize(line, colno, extra_chars)
+        character_str = extra_chars.length > 1 ? "characters" : "character"
+        super(line, line.indentation + colno, "extra #{character_str} after closing delimiter: ‘#{extra_chars}’.")
+      end
+    end
+
+    class InvalidIndentation < ParseError
+      def initialize(line, ind_exp)
+        prev_line = line.prev
+        if prev_line.nil? && ind_exp == 0
+          message = "top-level content must start in column 1."
+        elsif !prev_line.nil? &&
+              prev_line.attribs.key?("value") &&
+              prev_line.indentation < line.indentation &&
+              %i[dict_item list_item].member?(prev_line.tag)
+          message = "invalid indentation."
+        elsif !prev_line.nil? && line.indentation < prev_line.indentation
+          # Can't use ind_exp here, because it's a difference if the previous line was further indented. See test_load_error_dict_10
+          message = "invalid indentation, partial dedent."
+        else
+          message = "invalid indentation."
+        end
+        # Need to wrap like official tests. #wrap always add an extra \n we need to chop off.
+        message_wrapped = message.wrap(70).chop
+        super(line, ind_exp, message_wrapped)
+      end
+    end
+
+    class LineTypeNotExpected < ParseError
+      def initialize(line, type_exps, type_act)
+        super(line, line.indentation, "The current line was detected to be #{type_act}, but we expected to see any of [#{type_exps.join(", ")}] here.")
+      end
+    end
+
+    class LineTypeExpectedDictItem < ParseError
+      def initialize(line)
+        super(line, line.indentation, "expected dictionary item.")
+      end
+    end
+
+    class InvalidIndentationChar < ParseError
+      def initialize(line)
+        printable_char = line.content[0].dump.gsub(/"/, "")
+
+        # Looking for non-breaking space is just to be compatialbe with official tests.
+        explanation = ""
+        if printable_char == '\\u00A0'
+          printable_char = '\\xa0'
+          explanation = " (NO-BREAK SPACE)"
+        end
+
+        message = "invalid character in indentation: '#{printable_char}'#{explanation}."
+        super(line, line.indentation, message)
+      end
+    end
+
+    class DictDuplicateKey < ParseError
+      def initialize(line)
+        super(line, line.indentation, "duplicate key: #{line.attribs["key"]}.")
+      end
+    end
+
+    class ParseCustomClassNotFound < ParseError
+      def initialize(line, class_name)
+        super(line, line.indentation, "Detected an encode custom class #{class_name} however we can't find it, so it can't be deserialzied.")
+      end
+    end
+
+    class ParseCustomClassNoCreateMethod < ParseError
+      def initialize(line, class_name)
+        super(line, line.indentation, "Detected an encode custom class #{class_name} but it does not have a #nt_create method, so it can't be deserialzied.")
+      end
+    end
+
+    class UnsupportedTopLevelTypeError < Error
+      def initialize(type_class)
+        super("The given top level type #{type_class&.name} is unsupported. Chose between #{TOP_LEVEL_TYPES.join(", ")}.")
+      end
+    end
+
+    class WrongInputTypeError < Error
+      def initialize(class_exps, class_act)
+        super("The given input type #{class_act.class.name} is unsupported. Expected to be of types #{class_exps.map(&:name).join(", ")}")
+      end
+    end
+
+    class TopLevelTypeMismatchParsedType < Error
+      def initialize(class_exp, class_act)
+        super("The requested top level class #{class_exp.name} is not the same as the actual parsed top level class #{class_act}.")
+      end
+    end
+
+    class AssertionError < Error; end
+
+    class LineScannerIsEmpty < AssertionError
+      def initialize
+        super("There is no more input to consume. You should have checked this with #empty? before calling.")
+      end
+    end
+
+    class InlineScannerIsEmpty < AssertionError
+      def initialize
+        super("There is no more input to consume. You should have checked this with #empty? before calling.")
+      end
+    end
+
+    class DumpBadIO < Error
+      def initialize(io)
+        super("When giving the io argument, it must be of type IO (respond to #write, #fsync). Given: #{io.class.name}")
+      end
+    end
+
+    class DumpFileBadPath < Error
+      def initialize(path)
+        super("Must supply a string to a file path that can be written to. Given: #{path}")
+      end
+    end
+
+    class DumpError < Error
+      attr_reader :culprit
+
+      def initialize(culprit, message)
+        # Note, both line and column number are 0-indexed.
+        # But for human display we make them 1-indexed.
+        @culprit = culprit
+        super(message)
+      end
+    end
+
+    class DumpUnsupportedTypeError < DumpError
+      def initialize(obj, culprit)
+        # Needed to pass official test.
+        class_name = obj.is_a?(Integer) ? "int" : obj.class.name
+        super(culprit, "unsupported type (#{class_name}).")
+      end
+    end
+
+    class DumpCyclicReferencesDetected < DumpError
+      def initialize(culprit)
+        super(culprit, "cyclic reference found: cannot be dumped.")
+      end
+    end
+
+    class DumpHashKeyStrictString < DumpError
+      def initialize(obj)
+        super(obj, "keys must be strings.")
+      end
+    end
+
+    def self.raise_unrecognized_line(line)
+      # [[:space:]] include all Unicode spaces e.g. non-breakable space which \s does not.
+      raise InvalidIndentationChar, line if line.content.chr =~ /[[:space:]]/
+
+      raise LineTagNotDetected, line
+    end
+  end
+end

data/lib/nestedtext/helpers.rb

@@ -0,0 +1,7 @@
+module NestedText
+  def self.assert_valid_top_level_type(top_class)
+    unless !top_class.nil? && top_class.is_a?(Class) && TOP_LEVEL_TYPES.map(&:object_id).include?(top_class.object_id)
+      raise Errors::UnsupportedTopLevelTypeError, top_class
+    end
+  end
+end

data/lib/nestedtext/parser.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+require "nestedtext/errors"
+require "nestedtext/scanners"
+require "nestedtext/helpers"
+
+module NestedText
+  class Parser
+    # TODO: document that caller is responsible for closing IO after done with Parser.
+    def initialize(io, top_class, strict: true)
+      assert_valid_input_type io
+      NestedText.assert_valid_top_level_type(top_class)
+      @top_class = top_class
+      @strict = strict
+      @line_scanner = LineScanner.new(io)
+      @inline_scanner = nil
+    end
+
+    def parse
+      result = parse_any(0)
+      case @top_class.object_id
+      when Object.object_id
+        raise Errors::AssertionError, "Parsed result is of unexpected type." if
+        !result.nil? && ![Hash, Array, String].include?(result.class) && @strict
+      when Hash.object_id
+        result = {} if result.nil?
+        raise Errors::TopLevelTypeMismatchParsedType.new(@top_class, result) unless result.instance_of?(Hash)
+      when Array.object_id
+        result = [] if result.nil?
+        raise Errors::TopLevelTypeMismatchParsedType.new(@top_class, result) unless result.instance_of?(Array)
+      when String.object_id
+        result = "" if result.nil?
+        raise Errors::TopLevelTypeMismatchParsedType.new(@top_class, result) unless result.instance_of?(String)
+      else
+        raise Errors::UnsupportedTopLevelTypeError, @top_class
+      end
+      result
+    end
+
+    private
+
+    def assert_valid_input_type(input)
+      unless input.nil? || input.is_a?(IO) || input.is_a?(StringIO)
+        raise Errors::WrongInputTypeError.new([IO, StringIO], input)
+      end
+    end
+
+    def parse_any(indentation)
+      return nil if @line_scanner.peek.nil?
+
+      case @line_scanner.peek.tag # TODO: Use Null Pattern instead with a EndOfInput tag?
+      when :list_item
+        parse_list_item(indentation)
+      when :dict_item, :key_item
+        parse_dict_item(indentation)
+      when :string_item
+        parse_string_item(indentation)
+      when :inline_dict
+        parse_inline_dict
+      when :inline_list
+        parse_inline_list
+      when :unrecognized
+        Errors.raise_unrecognized_line(@line_scanner.peek)
+      else
+        raise Errors::AssertionError, "Unexpected line tag! #{@line_scanner.peek.tag}"
+      end
+    end
+
+    def parse_list_item(indentation)
+      result = []
+      while !@line_scanner.peek.nil? && @line_scanner.peek.indentation >= indentation
+        line = @line_scanner.read_next
+
+        Errors.raise_unrecognized_line(line) if line.tag == :unrecognized
+        raise Errors::LineTypeExpectedListItem, line unless line.tag == :list_item
+        raise Errors::InvalidIndentation.new(line, indentation) if line.indentation != indentation
+
+        value = line.attribs["value"]
+        if value.nil?
+          if !@line_scanner.peek.nil? && @line_scanner.peek.indentation > indentation
+            value = parse_any(@line_scanner.peek.indentation)
+          elsif @line_scanner.peek.nil? || @line_scanner.peek.tag == :list_item
+            value = ""
+          end
+        end
+
+        result << value
+      end
+      result
+    end
+
+    def parse_dict_item(indentation)
+      result = {}
+      first_line = nil
+      while !@line_scanner.peek.nil? && @line_scanner.peek.indentation >= indentation
+        line = @line_scanner.read_next
+        first_line = line if first_line.nil?
+        Errors.raise_unrecognized_line(line) if line.tag == :unrecognized
+        raise Errors::InvalidIndentation.new(line, indentation) if line.indentation != indentation
+        raise Errors::LineTypeExpectedDictItem, line unless %i[dict_item key_item].include? line.tag
+
+        value = nil
+        key = nil
+        if line.tag == :dict_item
+          key = line.attribs["key"]
+          value = line.attribs["value"]
+          if value.nil?
+            value = ""
+            if !@line_scanner.peek.nil? && @line_scanner.peek.indentation > indentation
+              value = parse_any(@line_scanner.peek.indentation)
+            end
+          end
+        else # :key_item
+          key = line.attribs["key"]
+          while @line_scanner.peek&.tag == :key_item && @line_scanner.peek.indentation == indentation
+            line = @line_scanner.read_next
+            key += "\n" + line.attribs["key"]
+          end
+          exp_types = %i[dict_item key_item list_item string_item]
+          if @line_scanner.peek.nil?
+            value = ""
+          else
+            unless exp_types.member?(@line_scanner.peek.tag)
+              raise Errors::LineTypeNotExpected.new(line, exp_types, line.tag)
+            end
+            raise Errors::MultilineKeyNoValue, line unless @line_scanner.peek.indentation > indentation
+
+            value = parse_any(@line_scanner.peek.indentation)
+          end
+        end
+        raise Errors::DictDuplicateKey, line if result.key? key
+
+        result[key] = value
+      end
+
+      # Custom class decoding.
+      if !@strict && result.length == 2 && result.key?(CUSTOM_CLASS_KEY)
+        class_name = result[CUSTOM_CLASS_KEY]
+        begin
+          clazz = class_name == "nil" ? NilClass : Object.const_get(class_name, false)
+        rescue NameError
+          raise Errors::ParseCustomClassNotFound.new(first_line, class_name)
+        end
+        if clazz.respond_to? :nt_create
+          result = clazz.nt_create(result["data"])
+        else
+          raise Errors::ParseCustomClassNoCreateMethod.new(first_line, class_name)
+        end
+      end
+
+      result
+    end
+
+    def parse_string_item(indentation)
+      result = []
+      while !@line_scanner.peek.nil? && @line_scanner.peek.indentation >= indentation
+        line = @line_scanner.read_next
+        raise Errors::InvalidIndentation.new(line, indentation) if line.indentation != indentation
+        raise Errors::LineTypeNotExpected.new(line, %i[string_item], line.tag) unless line.tag == :string_item
+
+        value = line.attribs["value"]
+        result << value
+      end
+      result.join("\n")
+    end
+
+    def parse_inline_key
+      key = []
+      until @inline_scanner.empty? || [":", "{", "}", "[", "]", ","].include?(@inline_scanner.peek)
+        key << @inline_scanner.read_next
+      end
+      if @inline_scanner.empty?
+        raise Errors::InlineNoClosingDelimiter.new(@inline_scanner.line,
+                                                   @inline_scanner.pos)
+      end
+
+      last_char = @inline_scanner.read_next
+      if last_char == "}" && key.empty?
+        raise Errors::InlineMissingValue.new(@inline_scanner.line, @inline_scanner.pos - 1)
+      end
+      unless last_char == ":"
+        raise Errors::InlineDictKeySyntaxError.new(@inline_scanner.line, @inline_scanner.pos - 1, last_char)
+      end
+
+      key.join.strip
+    end
+
+    def parse_inline
+      return nil if @inline_scanner.peek.nil?
+
+      result = nil
+      # Trim leading whitespaces
+      @inline_scanner.read_next while !@inline_scanner.empty? && [" ", "\t"].include?(@inline_scanner.peek)
+      case @inline_scanner.peek
+      when "{"
+        result = {}
+        first = true
+        loop do
+          @inline_scanner.read_next
+          break if first && @inline_scanner.peek == "}"
+
+          first = false
+          key = parse_inline_key
+          value = parse_inline
+          result[key] = value
+          break unless @inline_scanner.peek == ","
+        end
+        if @inline_scanner.empty?
+          raise Errors::InlineNoClosingDelimiter.new(@inline_scanner.line,
+                                                     @inline_scanner.pos)
+        end
+        last_char = @inline_scanner.read_next
+        unless last_char == "}"
+          raise Errors::InlineDictSyntaxError.new(@inline_scanner.line, @inline_scanner.pos - 1,
+                                                  last_char)
+        end
+
+      when "["
+        result = []
+        first = true # TODO: can be replaced by checking result.empty? below?
+        loop do
+          @inline_scanner.read_next
+          break if first && @inline_scanner.peek == "]"
+
+          first = false
+          result << parse_inline
+          break unless @inline_scanner.peek == ","
+        end
+        if @inline_scanner.empty?
+          raise Errors::InlineNoClosingDelimiter.new(@inline_scanner.line,
+                                                     @inline_scanner.pos)
+        end
+        last_char = @inline_scanner.read_next
+
+        if last_char != "]"
+          if result[-1] == ""
+            raise Errors::InlineMissingValue.new(@inline_scanner.line, @inline_scanner.pos - 1)
+          else
+            raise Errors::InlineListSyntaxError.new(@inline_scanner.line, @inline_scanner.pos - 1,
+                                                    last_char)
+          end
+        end
+      else # Inline string
+        inline_string = []
+        until @inline_scanner.empty? || ["{", "}", "[", "]", ","].include?(@inline_scanner.peek)
+          inline_string << @inline_scanner.read_next
+        end
+        result = inline_string.join.rstrip # Trim trailing whitespaces that lead up to next break point.
+      end
+      # Trim trailing whitespaces
+      @inline_scanner.read_next while !@inline_scanner.empty? && [" ", "\t"].include?(@inline_scanner.peek)
+      result
+    end
+
+    def parse_inline_dict
+      @inline_scanner = InlineScanner.new(@line_scanner.read_next)
+      result = parse_inline
+      unless @inline_scanner.empty?
+        raise Errors::InlineExtraCharactersAfterDelimiter.new(@inline_scanner.line, @inline_scanner.pos,
+                                                              @inline_scanner.remaining)
+      end
+      unless result.is_a? Hash
+        raise Errors::AssertionError,
+              "Expected inline value to be Hash but is #{result.class.name}"
+      end
+
+      result
+    end
+
+    def parse_inline_list
+      @inline_scanner = InlineScanner.new(@line_scanner.read_next)
+      result = parse_inline
+      unless @inline_scanner.empty?
+        raise Errors::InlineExtraCharactersAfterDelimiter.new(@inline_scanner.line, @inline_scanner.pos,
+                                                              @inline_scanner.remaining)
+      end
+      unless result.is_a? Array
+        raise Errors::AssertionError,
+              "Expected inline value to be Array but is #{result.class.name}"
+      end
+
+      result
+    end
+  end
+end