nestedtext 3.2.1 → 4.2.0

data/lib/nestedtext/errors_internal.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require "word_wrap"
-require "word_wrap/core_ext"
+require 'word_wrap'
+require 'word_wrap/core_ext'
+require 'unicode_utils'
 
-require "nestedtext/constants"
-require "nestedtext/error"
+require 'nestedtext/constants'
+require 'nestedtext/error'
 
 module NestedText
   module Errors
     class InternalError < Error
-      public_class_method :new # Prevent users from instansiating.
+      public_class_method :new # Prevent users from instantiating.
     end
 
     class ParseError < InternalError
@@ -26,26 +27,44 @@ module NestedText
 
       private
 
-      def pretty_message(line)
-        lineno_disp = @lineno + 1
-        colno_disp = @colno + 1
-        prefix = "\nParse ParseError (line #{lineno_disp}, column #{colno_disp}): "
+      def lineno_disp
+        @lineno + 1
+      end
+
+      def colno_disp
+        @colno + 1
+      end
+
+      # Number of digits in the line number.
+      def lineno_digits
+        lineno_disp.to_s.length
+      end
+
+      def pretty_prefix
+        "\nParse ParseError (line #{lineno_disp}, column #{colno_disp}): "
+      end
+
+      def pretty_line(line)
+        return '' if line.nil?
+
+        lline_indent = ' ' * line.indentation
+        prev_lineno_disp = line.lineno + 1
 
-        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}"
+        "\n\t#{prev_lineno_disp.to_s.rjust(lineno_digits)}│#{lline_indent}#{line.content}"
+      end
 
-        marker_indent = colno_disp + digits # +1 for the "|"
-        marker = "\n\t" + " " * marker_indent + "^"
+      def pretty_last_lines(line)
+        pretty_line(line.prev) + pretty_line(line)
+      end
 
-        prefix + @message_raw + last_lines + marker
+      def pretty_marker
+        marker_indent = colno_disp + lineno_digits # +1 for the "|"
+        "\n\t#{' ' * marker_indent}^"
+      end
+
+      def pretty_message(line)
+        pretty_prefix + @message_raw + pretty_last_lines(line) + pretty_marker
       end
     end
 
@@ -57,19 +76,19 @@ module NestedText
 
     class ParseLineTagNotDetectedError < ParseError
       def initialize(line)
-        super(line, line.indentation, "unrecognized line.")
+        super(line, line.indentation, 'unrecognized line.')
       end
     end
 
     class ParseLineTypeExpectedListItemError < ParseError
       def initialize(line)
-        super(line, line.indentation, "expected list item.")
+        super(line, line.indentation, 'expected list item.')
       end
     end
 
     class ParseMultilineKeyNoValueError < ParseError
       def initialize(line)
-        super(line, line.indentation, "multiline key requires a value.")
+        super(line, line.indentation, 'multiline key requires a value.')
       end
     end
 
@@ -87,7 +106,7 @@ module NestedText
 
     class ParseInlineMissingValueError < ParseError
       def initialize(line, colno)
-        super(line, line.indentation + colno, "expected value.")
+        super(line, line.indentation + colno, 'expected value.')
       end
     end
 
@@ -99,13 +118,13 @@ module NestedText
 
     class ParseInlineNoClosingDelimiterError < ParseError
       def initialize(line, colno)
-        super(line, line.indentation + colno, "line ended without closing delimiter.")
+        super(line, line.indentation + colno, 'line ended without closing delimiter.')
       end
     end
 
     class ParseInlineExtraCharactersAfterDelimiterError < ParseError
       def initialize(line, colno, extra_chars)
-        character_str = extra_chars.length > 1 ? "characters" : "character"
+        character_str = extra_chars.length > 1 ? 'characters' : 'character'
         super(line, line.indentation + colno, "extra #{character_str} after closing delimiter: ‘#{extra_chars}’.")
       end
     end
@@ -113,19 +132,15 @@ module NestedText
     class ParseInvalidIndentationError < 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
+        message = if prev_line.nil? && ind_exp.zero?
+                    'top-level content must start in column 1.'
+                  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
+                    'invalid indentation, partial dedent.'
+                  else
+                    '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)
@@ -134,26 +149,27 @@ module NestedText
 
     class ParseLineTypeNotExpectedError < 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.")
+        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 ParseLineTypeExpectedDictItemError < ParseError
       def initialize(line)
-        super(line, line.indentation, "expected dictionary item.")
+        super(line, line.indentation, 'expected dictionary item.')
       end
     end
 
     class ParseInvalidIndentationCharError < ParseError
       def initialize(line)
-        printable_char = line.content[0].dump.gsub(/"/, "")
+        char = line.content[0]
+        # Official-test kludge; Translate rubys \u00 to python's unicodedata.name \x format.
+        printable_char = char.dump.gsub(/"/, '').gsub(/\\u0*/, '\x').downcase
 
-        # 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
+        explanation = ''
+        # Official-test kludge; ASCII chars have printable names too, but they are not used in reference implementation.
+        explanation = " (#{UnicodeUtils.char_name(char)})" unless char.ord < 128
 
         message = "invalid character in indentation: '#{printable_char}'#{explanation}."
         super(line, line.indentation, message)
@@ -162,19 +178,23 @@ module NestedText
 
     class ParseDictDuplicateKeyError < ParseError
       def initialize(line)
-        super(line, line.indentation, "duplicate key: #{line.attribs["key"]}.")
+        super(line, line.indentation, "duplicate key: #{line.attribs['key']}.")
       end
     end
 
     class ParseCustomClassNotFoundError < 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.")
+        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 ParseCustomClassNoCreateMethodError < 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.")
+        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
 
@@ -182,13 +202,13 @@ module NestedText
 
     class AssertionLineScannerIsEmptyError < AssertionError
       def initialize
-        super("There is no more input to consume. You should have checked this with #empty? before calling.")
+        super('There is no more input to consume. You should have checked this with #empty? before calling.')
       end
     end
 
     class AssertionInlineScannerIsEmptyError < AssertionError
       def initialize
-        super("There is no more input to consume. You should have checked this with #empty? before calling.")
+        super('There is no more input to consume. You should have checked this with #empty? before calling.')
       end
     end
 
@@ -206,20 +226,20 @@ module NestedText
     class DumpUnsupportedTypeError < DumpError
       def initialize(obj, culprit)
         # Needed to pass official test.
-        class_name = obj.is_a?(Integer) ? "int" : obj.class.name
+        class_name = obj.is_a?(Integer) ? 'int' : obj.class.name
         super(culprit, "unsupported type (#{class_name}).")
       end
     end
 
     class DumpCyclicReferencesDetectedError < DumpError
       def initialize(culprit)
-        super(culprit, "cyclic reference found: cannot be dumped.")
+        super(culprit, 'cyclic reference found: cannot be dumped.')
       end
     end
 
     class DumpHashKeyStrictStringError < DumpError
       def initialize(obj)
-        super(obj, "keys must be strings.")
+        super(obj, 'keys must be strings.')
       end
     end
 
@@ -232,25 +252,29 @@ module NestedText
 
     class UnsupportedTopLevelTypeError < InternalError
       def initialize(type_class)
-        super("The given top level type #{type_class&.name} is unsupported. Chose between #{TOP_LEVEL_TYPES.join(", ")}.")
+        super("The given top level type #{type_class&.name} is unsupported." \
+              "Chose between #{TOP_LEVEL_TYPES.join(', ')}.")
       end
     end
 
     class WrongInputTypeError < InternalError
       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(", ")}")
+        super("The given input type #{class_act.class.name} is unsupported. " \
+              "Expected to be of types #{class_exps.map(&:name).join(', ')}")
       end
     end
 
     class TopLevelTypeMismatchParsedTypeError < InternalError
       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}.")
+        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 DumpBadIOError < InternalError
       def initialize(io)
-        super("When giving the io argument, it must be of type IO (respond to #write, #fsync). Given: #{io.class.name}")
+        super('When giving the io argument, it must be of type IO (respond to #write, #fsync).' \
+              " Given: #{io.class.name}")
       end
     end
 

data/lib/nestedtext/inline_parser.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'nestedtext/errors_internal'
+require 'nestedtext/scanners'
+
+module NestedText
+  # A LL(1) recursive descent parser for inline NT types.
+  class InlineParser # rubocop:disable Metrics/ClassLength
+    def initialize(line)
+      @inline_scanner = InlineScanner.new(line)
+    end
+
+    def parse
+      result = parse_any
+      unless @inline_scanner.empty?
+        raise Errors::ParseInlineExtraCharactersAfterDelimiterError.new(@inline_scanner.line, @inline_scanner.pos,
+                                                                        @inline_scanner.remaining)
+      end
+      result
+    end
+
+    private
+
+    def parse_any
+      return nil if @inline_scanner.peek.nil?
+
+      consume_whitespaces # Leading
+      result = case @inline_scanner.peek
+               when '{'
+                 parse_dict
+               when '['
+                 parse_list
+               else # Inline string
+                 parse_string
+               end
+
+      consume_whitespaces # Trailing
+      result
+    end
+
+    def consume_whitespaces
+      @inline_scanner.read_next while !@inline_scanner.empty? && [' ', "\t"].include?(@inline_scanner.peek)
+    end
+
+    def parse_key_last_char(key)
+      last_char = @inline_scanner.read_next
+      if last_char == '}' && key.empty?
+        raise Errors::ParseInlineMissingValueError.new(@inline_scanner.line, @inline_scanner.pos - 1)
+      end
+      return if last_char == ':'
+
+      raise Errors::ParseInlineDictKeySyntaxError.new(@inline_scanner.line, @inline_scanner.pos - 1, last_char)
+    end
+
+    def parse_key
+      key = []
+      until @inline_scanner.empty? || [':', '{', '}', '[', ']', ','].include?(@inline_scanner.peek)
+        key << @inline_scanner.read_next
+      end
+      if @inline_scanner.empty?
+        raise Errors::ParseInlineNoClosingDelimiterError.new(@inline_scanner.line,
+                                                             @inline_scanner.pos)
+      end
+      parse_key_last_char(key)
+      key.join.strip
+    end
+
+    def parse_dict_last_char
+      last_char = @inline_scanner.read_next
+      return if last_char == '}'
+
+      raise Errors::ParseInlineDictSyntaxError.new(@inline_scanner.line,
+                                                   @inline_scanner.pos - 1, last_char)
+    end
+
+    def parse_dict
+      result = {}
+      loop do
+        @inline_scanner.read_next
+        break if result.empty? && @inline_scanner.peek == '}'
+
+        key = parse_key
+        value = parse_any
+        result[key] = value
+        break unless @inline_scanner.peek == ','
+      end
+      if @inline_scanner.empty?
+        raise Errors::ParseInlineNoClosingDelimiterError.new(@inline_scanner.line,
+                                                             @inline_scanner.pos)
+      end
+      parse_dict_last_char
+      result
+    end
+
+    def parse_list_last_char(result)
+      last_char = @inline_scanner.read_next
+      return unless last_char != ']'
+
+      if result[-1] == ''
+        raise Errors::ParseInlineMissingValueError.new(@inline_scanner.line,
+                                                       @inline_scanner.pos - 1)
+      else
+        raise Errors::ParseInlineListSyntaxError.new(@inline_scanner.line,
+                                                     @inline_scanner.pos - 1, last_char)
+      end
+    end
+
+    def parse_list
+      result = []
+      loop do
+        @inline_scanner.read_next
+        break if result.empty? && @inline_scanner.peek == ']'
+
+        result << parse_any
+        break unless @inline_scanner.peek == ','
+      end
+      if @inline_scanner.empty?
+        raise Errors::ParseInlineNoClosingDelimiterError.new(@inline_scanner.line,
+                                                             @inline_scanner.pos)
+      end
+      parse_list_last_char(result)
+      result
+    end
+
+    def parse_string
+      inline_string = []
+      until @inline_scanner.empty? || ['{', '}', '[', ']', ','].include?(@inline_scanner.peek)
+        inline_string << @inline_scanner.read_next
+      end
+      inline_string.join.rstrip # Trim trailing whitespaces that lead up to next break point.
+    end
+  end
+  private_constant :InlineParser
+end