sorbet-toon 0.1.0

data/lib/sorbet/toon/decode/parser.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+require_relative '../errors'
+require_relative '../shared/string_utils'
+require_relative '../shared/validation'
+require_relative '../shared/literal_utils'
+
+module Sorbet
+  module Toon
+    module Decode
+      module Parser
+        module_function
+
+        def parse_array_header_line(content, default_delimiter)
+          trimmed = content.lstrip
+
+          bracket_start = find_bracket_start(trimmed, content)
+          return nil unless bracket_start
+
+          bracket_end = content.index(Constants::CLOSE_BRACKET, bracket_start)
+          return nil unless bracket_end
+
+          colon_index = find_colon_after_brackets(content, bracket_end)
+          return nil unless colon_index
+
+          key = extract_key_from_header(content, bracket_start)
+
+          bracket_content = content[(bracket_start + 1)...bracket_end]
+          parsed_segment = parse_bracket_segment(bracket_content, default_delimiter)
+          return nil unless parsed_segment
+
+          fields = extract_fields(content, bracket_end, colon_index, parsed_segment[:delimiter])
+
+          after_colon = content[(colon_index + 1)..]&.strip
+
+          header = {
+            key: key,
+            length: parsed_segment[:length],
+            delimiter: parsed_segment[:delimiter],
+            fields: fields,
+            has_length_marker: parsed_segment[:has_length_marker]
+          }
+
+          {
+            header: header,
+            inline_values: after_colon&.empty? ? nil : after_colon
+          }
+        end
+
+        def parse_bracket_segment(segment, default_delimiter)
+          content = segment
+          has_length_marker = false
+
+          if content.start_with?(Constants::HASH)
+            has_length_marker = true
+            content = content[1..]
+          end
+
+          delimiter = default_delimiter
+          if content.end_with?(Constants::TAB)
+            delimiter = Constants::TAB
+            content = content[0...-1]
+          elsif content.end_with?(Constants::PIPE)
+            delimiter = Constants::PIPE
+            content = content[0...-1]
+          end
+
+          length = Integer(content, exception: false)
+          return nil if length.nil?
+
+          {
+            length: length,
+            delimiter: delimiter,
+            has_length_marker: has_length_marker
+          }
+        end
+
+        def parse_delimited_values(input, delimiter)
+          values = []
+          current = +''
+          in_quotes = false
+          i = 0
+
+          while i < input.length
+            char = input[i]
+
+            if char == Constants::BACKSLASH && in_quotes && (i + 1) < input.length
+              current << char << input[i + 1]
+              i += 2
+              next
+            end
+
+            if char == Constants::DOUBLE_QUOTE
+              in_quotes = !in_quotes
+              current << char
+              i += 1
+              next
+            end
+
+            if char == delimiter && !in_quotes
+              values << current.strip
+              current = +''
+              i += 1
+              next
+            end
+
+            current << char
+            i += 1
+          end
+
+          values << current.strip if !current.empty? || !values.empty?
+          values
+        end
+
+        def map_row_values_to_primitives(values)
+          values.map { |token| parse_primitive_token(token) }
+        end
+
+        def parse_primitive_token(token)
+          trimmed = token.strip
+          return '' if trimmed.empty?
+
+          if trimmed.start_with?(Constants::DOUBLE_QUOTE)
+            if trimmed.length < 2 || trimmed[-1] != Constants::DOUBLE_QUOTE
+              raise Sorbet::Toon::DecodeError, "Unterminated string literal: #{trimmed}"
+            end
+            inner = trimmed[1...-1]
+            return Shared::StringUtils.unescape_string(inner)
+          end
+
+          case trimmed
+          when Constants::TRUE_LITERAL
+            true
+          when Constants::FALSE_LITERAL
+            false
+          when Constants::NULL_LITERAL
+            nil
+          else
+            if Shared::LiteralUtils.numeric_literal?(trimmed)
+              parsed = Float(trimmed)
+              return 0 if parsed.zero?
+              return parsed
+            end
+            trimmed
+          end
+        end
+
+        def parse_key_token(content, start_index)
+          if content[start_index] == Constants::DOUBLE_QUOTE
+            closing = Shared::StringUtils.find_closing_quote(content, start_index)
+            raise Sorbet::Toon::DecodeError, 'Unterminated quoted key' if closing == -1
+
+            key = Shared::StringUtils.unescape_string(content[(start_index + 1)...closing])
+            rest_index = closing + 1
+            colon_index = Shared::StringUtils.find_unquoted_char(content, Constants::COLON, rest_index)
+            raise Sorbet::Toon::DecodeError, 'Key must be followed by colon' if colon_index == -1
+            return { key: key, end: colon_index + 1 }
+          end
+
+          colon_index = Shared::StringUtils.find_unquoted_char(content, Constants::COLON, start_index)
+          raise Sorbet::Toon::DecodeError, 'Key must be followed by colon' if colon_index == -1
+
+          key = content[start_index...colon_index].strip
+          { key: key, end: colon_index + 1 }
+        end
+
+        def find_bracket_start(trimmed, original)
+          if trimmed.start_with?(Constants::DOUBLE_QUOTE)
+            closing_quote = Shared::StringUtils.find_closing_quote(trimmed, 0)
+            return nil if closing_quote == -1
+            key_end_in_original = original.length - trimmed.length + closing_quote + 1
+            original.index(Constants::OPEN_BRACKET, key_end_in_original)
+          else
+            original.index(Constants::OPEN_BRACKET)
+          end
+        end
+        private_class_method :find_bracket_start
+
+        def find_colon_after_brackets(content, bracket_end)
+          brace_end = bracket_end
+          brace_start = content.index(Constants::OPEN_BRACE, bracket_end)
+          colon_after_bracket = content.index(Constants::COLON, bracket_end)
+
+          if brace_start && colon_after_bracket && brace_start < colon_after_bracket
+            found_brace_end = content.index(Constants::CLOSE_BRACE, brace_start)
+            brace_end = found_brace_end ? found_brace_end + 1 : brace_end
+          end
+
+          search_start = [bracket_end, brace_end].max
+          content.index(Constants::COLON, search_start)
+        end
+        private_class_method :find_colon_after_brackets
+
+        def extract_key_from_header(content, bracket_start)
+          return nil if bracket_start.zero?
+
+          raw_key = content[0...bracket_start].strip
+          return nil if raw_key.empty?
+
+          if raw_key.start_with?(Constants::DOUBLE_QUOTE)
+            closing = Shared::StringUtils.find_closing_quote(raw_key, 0)
+            raise Sorbet::Toon::DecodeError, 'Unterminated quoted key' if closing == -1
+
+            return Shared::StringUtils.unescape_string(raw_key[1...closing])
+          end
+
+          raw_key
+        end
+        private_class_method :extract_key_from_header
+
+        def extract_fields(content, bracket_end, colon_index, delimiter)
+          brace_start = content.index(Constants::OPEN_BRACE, bracket_end)
+          return nil unless brace_start && brace_start < colon_index
+
+          brace_end = content.index(Constants::CLOSE_BRACE, brace_start)
+          return nil unless brace_end && brace_end < colon_index
+
+          fields_content = content[(brace_start + 1)...brace_end]
+          ensure_matching_field_delimiter!(fields_content, delimiter)
+          parse_delimited_values(fields_content, delimiter).map do |field|
+            field.strip!
+            if field.start_with?(Constants::DOUBLE_QUOTE)
+              Shared::StringUtils.unescape_string(field[1...-1])
+            else
+              field
+            end
+          end
+        end
+        private_class_method :extract_fields
+
+        def array_header_after_hyphen?(content)
+          stripped = content.strip
+          stripped.start_with?(Constants::OPEN_BRACKET) &&
+            Shared::StringUtils.find_unquoted_char(content, Constants::COLON) != -1
+        end
+
+        def object_first_field_after_hyphen?(content)
+          Shared::StringUtils.find_unquoted_char(content, Constants::COLON) != -1
+        end
+
+        def ensure_matching_field_delimiter!(content, delimiter)
+          other_delimiters = Constants::DELIMITERS.values.reject { |value| value == delimiter }
+          other_delimiters.each do |other|
+            next if Shared::StringUtils.find_unquoted_char(content, other).negative?
+
+            raise Sorbet::Toon::DecodeError,
+                  "Field delimiter mismatch: expected #{describe_delimiter(delimiter)} but found #{describe_delimiter(other)}"
+          end
+        end
+        private_class_method :ensure_matching_field_delimiter!
+
+        def describe_delimiter(delimiter)
+          case delimiter
+          when Constants::TAB
+            'tab (\\t)'
+          when Constants::PIPE
+            'pipe (|)'
+          else
+            'comma (,)'
+          end
+        end
+        private_class_method :describe_delimiter
+      end
+    end
+  end
+end

data/lib/sorbet/toon/decode/scanner.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+
+module Sorbet
+  module Toon
+    module Decode
+      ParsedLine = Struct.new(:raw, :indent, :content, :depth, :line_number, keyword_init: true)
+      BlankLineInfo = Struct.new(:line_number, :indent, :depth, keyword_init: true)
+
+      class LineCursor
+        attr_reader :blank_lines
+
+        def initialize(lines, blank_lines = [])
+          @lines = lines
+          @blank_lines = blank_lines
+          @index = 0
+        end
+
+        def peek
+          @lines[@index]
+        end
+
+        def next
+          line = @lines[@index]
+          @index += 1 if line
+          line
+        end
+
+        def advance
+          @index += 1
+        end
+
+        def current
+          @index.positive? ? @lines[@index - 1] : nil
+        end
+
+        def at_end?
+          @index >= @lines.length
+        end
+
+        def length
+          @lines.length
+        end
+
+        def peek_at_depth(target_depth)
+          line = peek
+          return nil unless line
+          return nil if line.depth < target_depth
+          return line if line.depth == target_depth
+
+          nil
+        end
+
+        def has_more_at_depth?(target_depth)
+          !peek_at_depth(target_depth).nil?
+        end
+      end
+
+      module Scanner
+        module_function
+
+        def to_parsed_lines(source, indent_size, strict)
+          return { lines: [], blank_lines: [] } if source.nil? || source.strip.empty?
+
+          raw_lines = source.split("\n", -1)
+          parsed_lines = []
+          blank_lines = []
+
+          raw_lines.each_with_index do |raw, index|
+            line_number = index + 1
+            leading_whitespace = raw[/\A[ \t]*/] || ''
+            indent = leading_whitespace.count(Constants::SPACE)
+            content = raw[leading_whitespace.length..] || ''
+
+            if content.strip.empty?
+              depth = compute_depth_from_indent(indent, indent_size)
+              blank_lines << BlankLineInfo.new(line_number: line_number, indent: indent, depth: depth)
+              next
+            end
+
+            depth = compute_depth_from_indent(indent, indent_size)
+
+            if strict
+              validate_leading_whitespace!(leading_whitespace, line_number, indent, indent_size)
+            end
+
+            parsed_lines << ParsedLine.new(
+              raw: raw,
+              indent: indent,
+              content: content,
+              depth: depth,
+              line_number: line_number
+            )
+          end
+
+          { lines: parsed_lines, blank_lines: blank_lines }
+        end
+
+        def compute_depth_from_indent(indent_spaces, indent_size)
+          (indent_spaces / indent_size.to_f).floor
+        end
+        private_class_method :compute_depth_from_indent
+
+        def validate_leading_whitespace!(leading_whitespace, line_number, indent, indent_size)
+          if leading_whitespace.include?(Constants::TAB)
+            raise RuntimeError, "Line #{line_number}: Tabs are not allowed in indentation in strict mode"
+          end
+
+          if indent.positive? && (indent % indent_size != 0)
+            raise RuntimeError, "Line #{line_number}: Indentation must be exact multiple of #{indent_size}, but found #{indent} spaces"
+          end
+        end
+        private_class_method :validate_leading_whitespace!
+      end
+    end
+  end
+end

data/lib/sorbet/toon/decode/validation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+require_relative '../errors'
+
+module Sorbet
+  module Toon
+    module Decode
+      module Validation
+        module_function
+
+        def assert_expected_count(actual, expected, item_type, strict:)
+          return unless strict
+          return if actual == expected
+
+          raise RangeError, "Expected #{expected} #{item_type}, but got #{actual}"
+        end
+
+        def validate_no_extra_list_items(cursor, item_depth, expected_count)
+          return if cursor.at_end?
+
+          next_line = cursor.peek
+          if next_line && next_line.depth == item_depth && next_line.content.start_with?(Constants::LIST_ITEM_PREFIX)
+            raise RangeError, "Expected #{expected_count} list array items, but found more"
+          end
+        end
+
+        def validate_no_extra_tabular_rows(cursor, row_depth, header)
+          return if cursor.at_end?
+
+          next_line = cursor.peek
+          if next_line &&
+             next_line.depth == row_depth &&
+             !next_line.content.start_with?(Constants::LIST_ITEM_PREFIX) &&
+             data_row?(next_line.content, header[:delimiter])
+            raise RangeError, "Expected #{header[:length]} tabular rows, but found more"
+          end
+        end
+
+        def validate_no_blank_lines_in_range(start_line, end_line, blank_lines, strict:, context:)
+          return unless strict
+
+          blanks_in_range = blank_lines.select do |blank|
+            blank.line_number > start_line && blank.line_number < end_line
+          end
+
+          return if blanks_in_range.empty?
+
+          raise Sorbet::Toon::DecodeError,
+                "Line #{blanks_in_range.first.line_number}: Blank lines inside #{context} are not allowed in strict mode"
+        end
+
+        def data_row?(content, delimiter)
+          colon_pos = content.index(Constants::COLON)
+          delimiter_pos = content.index(delimiter)
+
+          return true if colon_pos.nil?
+          return true if delimiter_pos && delimiter_pos < colon_pos
+
+          false
+        end
+        private_class_method :data_row?
+      end
+    end
+  end
+end

data/lib/sorbet/toon/decoder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'codec'
+require_relative 'reconstructor'
+
+module Sorbet
+  module Toon
+    module Decoder
+      CONFIG_KEYS = %i[indent strict].freeze
+
+      class << self
+        def decode(payload, config:, signature: nil, role: :output, struct_class: nil, **overrides)
+          config_overrides = extract_overrides(overrides, CONFIG_KEYS)
+          resolved = config.resolve(config_overrides)
+
+          decoded = Sorbet::Toon::Codec.decode(
+            payload,
+            indent: resolved.indent,
+            strict: resolved.strict
+          )
+
+          Sorbet::Toon::Reconstructor.reconstruct(
+            decoded,
+            signature: signature,
+            struct_class: struct_class,
+            role: role
+          )
+        end
+
+        private
+
+        def extract_overrides(options, keys)
+          keys.each_with_object({}) do |key, memo|
+            next unless options.key?(key)
+
+            memo[key] = options.delete(key)
+          end
+        end
+      end
+    end
+  end
+end