sorbet-toon 0.1.0

data/lib/sorbet/toon/encode/encoders.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+require_relative 'normalize'
+require_relative 'primitives'
+require_relative 'writer'
+
+module Sorbet
+  module Toon
+    module Encode
+      module Encoders
+        module_function
+
+        ResolvedOptions = Struct.new(:indent, :delimiter, :length_marker, keyword_init: true)
+
+        def encode_value(value, options)
+          options = resolve_options(options)
+
+          if Normalize.json_primitive?(value)
+            return Primitives.encode_primitive(value, options.delimiter)
+          end
+
+          writer = Writer.new(options.indent)
+
+          if Normalize.json_array?(value)
+            encode_array(nil, value, writer, 0, options)
+          elsif Normalize.json_object?(value)
+            encode_object(value, writer, 0, options)
+          end
+
+          writer.to_s
+        end
+
+        def encode_object(object, writer, depth, options)
+          object.each do |key, val|
+            encode_key_value_pair(key, val, writer, depth, options)
+          end
+        end
+
+        def encode_key_value_pair(key, value, writer, depth, options)
+          encoded_key = Primitives.encode_key(key)
+
+          if Normalize.json_primitive?(value)
+            writer.push(depth, "#{encoded_key}: #{Primitives.encode_primitive(value, options.delimiter)}")
+          elsif Normalize.json_array?(value)
+            encode_array(key, value, writer, depth, options)
+          elsif Normalize.json_object?(value)
+            nested_keys = value.keys
+            if nested_keys.empty?
+              writer.push(depth, "#{encoded_key}:")
+            else
+              writer.push(depth, "#{encoded_key}:")
+              encode_object(value, writer, depth + 1, options)
+            end
+          end
+        end
+
+        def encode_array(key, array, writer, depth, options)
+          if array.empty?
+            header = Primitives.format_header(0, key: key, delimiter: options.delimiter, length_marker: options.length_marker)
+            writer.push(depth, header)
+            return
+          end
+
+          if Normalize.array_of_primitives?(array)
+            formatted = encode_inline_array_line(array, options.delimiter, key, options.length_marker)
+            writer.push(depth, formatted)
+            return
+          end
+
+          if Normalize.array_of_arrays?(array)
+            all_primitive = array.all? { |arr| Normalize.array_of_primitives?(arr) }
+            if all_primitive
+              encode_array_of_arrays_as_list_items(key, array, writer, depth, options)
+              return
+            end
+          end
+
+          if Normalize.array_of_objects?(array)
+            header = extract_tabular_header(array)
+            if header
+              encode_array_of_objects_as_tabular(key, array, header, writer, depth, options)
+            else
+              encode_mixed_array_as_list_items(key, array, writer, depth, options)
+            end
+            return
+          end
+
+          encode_mixed_array_as_list_items(key, array, writer, depth, options)
+        end
+
+        def encode_array_of_arrays_as_list_items(prefix, values, writer, depth, options)
+          header = Primitives.format_header(values.length, key: prefix, delimiter: options.delimiter, length_marker: options.length_marker)
+          writer.push(depth, header)
+
+          values.each do |arr|
+            next unless Normalize.array_of_primitives?(arr)
+
+            inline = encode_inline_array_line(arr, options.delimiter, nil, options.length_marker)
+            writer.push_list_item(depth + 1, inline)
+          end
+        end
+
+        def encode_inline_array_line(values, delimiter, prefix = nil, length_marker = false)
+          header = Primitives.format_header(values.length, key: prefix, delimiter: delimiter, length_marker: length_marker)
+          return header if values.empty?
+
+          joined = Primitives.encode_and_join_primitives(values, delimiter)
+          "#{header} #{joined}"
+        end
+
+        def encode_array_of_objects_as_tabular(prefix, rows, header_keys, writer, depth, options)
+          formatted_header = Primitives.format_header(
+            rows.length,
+            key: prefix,
+            fields: header_keys,
+            delimiter: options.delimiter,
+            length_marker: options.length_marker
+          )
+          writer.push(depth, formatted_header)
+          write_tabular_rows(rows, header_keys, writer, depth + 1, options)
+        end
+
+        def extract_tabular_header(rows)
+          return nil if rows.empty?
+
+          first_row = rows.first
+          header = first_row.keys
+          return nil if header.empty?
+          return header if is_tabular_array(rows, header)
+
+          nil
+        end
+
+        def is_tabular_array(rows, header)
+          rows.all? do |row|
+            keys = row.keys
+            next false unless keys.length == header.length
+
+            header.all? do |key|
+              row.key?(key) && Normalize.json_primitive?(row[key])
+            end
+          end
+        end
+
+        def write_tabular_rows(rows, header, writer, depth, options)
+          rows.each do |row|
+            values = header.map { |key| row[key] }
+            joined = Primitives.encode_and_join_primitives(values, options.delimiter)
+            writer.push(depth, joined)
+          end
+        end
+
+        def encode_mixed_array_as_list_items(prefix, items, writer, depth, options)
+          header = Primitives.format_header(items.length, key: prefix, delimiter: options.delimiter, length_marker: options.length_marker)
+          writer.push(depth, header)
+
+          items.each do |item|
+            encode_list_item_value(item, writer, depth + 1, options)
+          end
+        end
+
+        def encode_object_as_list_item(object, writer, depth, options)
+          keys = object.keys
+          if keys.empty?
+            writer.push(depth, Constants::LIST_ITEM_MARKER)
+            return
+          end
+
+          first_key = keys.first
+          first_value = object[first_key]
+          encoded_first_key = Primitives.encode_key(first_key)
+
+          if Normalize.json_primitive?(first_value)
+            writer.push_list_item(depth, "#{encoded_first_key}: #{Primitives.encode_primitive(first_value, options.delimiter)}")
+          elsif Normalize.json_array?(first_value)
+            handle_first_array_item(encoded_first_key, first_key, first_value, writer, depth, options)
+          elsif Normalize.json_object?(first_value)
+            nested_keys = first_value.keys
+            if nested_keys.empty?
+              writer.push_list_item(depth, "#{encoded_first_key}:")
+            else
+              writer.push_list_item(depth, "#{encoded_first_key}:")
+              encode_object(first_value, writer, depth + 2, options)
+            end
+          end
+
+          keys.drop(1).each do |key|
+            encode_key_value_pair(key, object[key], writer, depth + 1, options)
+          end
+        end
+
+        def encode_list_item_value(value, writer, depth, options)
+          if Normalize.json_primitive?(value)
+            writer.push_list_item(depth, Primitives.encode_primitive(value, options.delimiter))
+          elsif Normalize.json_array?(value) && Normalize.array_of_primitives?(value)
+            inline = encode_inline_array_line(value, options.delimiter, nil, options.length_marker)
+            writer.push_list_item(depth, inline)
+          elsif Normalize.json_object?(value)
+            encode_object_as_list_item(value, writer, depth, options)
+          end
+        end
+
+        def handle_first_array_item(encoded_key, raw_key, array, writer, depth, options)
+          if Normalize.array_of_primitives?(array)
+            formatted = encode_inline_array_line(array, options.delimiter, raw_key, options.length_marker)
+            writer.push_list_item(depth, formatted)
+          elsif Normalize.array_of_objects?(array)
+            header = extract_tabular_header(array)
+            if header
+              formatted_header = Primitives.format_header(
+                array.length,
+                key: raw_key,
+                fields: header,
+                delimiter: options.delimiter,
+                length_marker: options.length_marker
+              )
+              writer.push_list_item(depth, formatted_header)
+              write_tabular_rows(array, header, writer, depth + 1, options)
+            else
+              writer.push_list_item(depth, "#{encoded_key}[#{array.length}]:")
+              array.each do |item|
+                encode_object_as_list_item(item, writer, depth + 1, options)
+              end
+            end
+          else
+            writer.push_list_item(depth, "#{encoded_key}[#{array.length}]:")
+            array.each do |item|
+              encode_list_item_value(item, writer, depth + 1, options)
+            end
+          end
+        end
+        private_class_method :handle_first_array_item
+
+        def resolve_options(opts)
+          ResolvedOptions.new(
+            indent: opts[:indent] || 2,
+            delimiter: opts[:delimiter] || Constants::DEFAULT_DELIMITER,
+            length_marker: opts[:length_marker] || false
+          )
+        end
+        private_class_method :resolve_options
+      end
+    end
+  end
+end

data/lib/sorbet/toon/encode/normalize.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'set'
+require 'bigdecimal'
+
+module Sorbet
+  module Toon
+    module Encode
+      module Normalize
+        module_function
+
+        def normalize(value)
+          case value
+          when nil
+            nil
+          when String, TrueClass, FalseClass
+            value
+          when Integer
+            normalize_integer(value)
+          when Float
+            normalize_float(value)
+          when Rational
+            normalize_float(value.to_f)
+          when BigDecimal
+            normalize_float(value.to_f)
+          when Time, DateTime
+            value.iso8601
+          when Date
+            value.iso8601
+          when Array
+            value.map { |item| normalize(item) }
+          when Set
+            value.map { |item| normalize(item) }
+          when Hash
+            normalize_hash(value)
+          else
+            try_custom_normalize(value)
+          end
+        end
+
+        def json_primitive?(value)
+          value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+        end
+
+        def json_array?(value)
+          value.is_a?(Array)
+        end
+
+        def json_object?(value)
+          value.is_a?(Hash)
+        end
+
+        def array_of_primitives?(array)
+          array.all? { |item| json_primitive?(item) }
+        end
+
+        def array_of_arrays?(array)
+          array.all? { |item| json_array?(item) }
+        end
+
+        def array_of_objects?(array)
+          array.all? { |item| json_object?(item) }
+        end
+
+        def is_plain_object?(value)
+          value.is_a?(Hash)
+        end
+
+        def normalize_integer(value)
+          value
+        end
+        private_class_method :normalize_integer
+
+        def normalize_float(value)
+          return 0 if value.zero?
+          return nil unless value.finite?
+          value
+        end
+        private_class_method :normalize_float
+
+        def normalize_hash(hash)
+          result = {}
+          hash.each do |key, val|
+            result[key.to_s] = normalize(val)
+          end
+          result
+        end
+        private_class_method :normalize_hash
+
+        def try_custom_normalize(value)
+          if value.respond_to?(:to_ary)
+            normalize(value.to_ary)
+          elsif value.respond_to?(:to_hash)
+            normalize_hash(value.to_hash)
+          elsif value.respond_to?(:to_h)
+            normalize_hash(value.to_h)
+          elsif value.respond_to?(:to_s)
+            value.to_s
+          else
+            nil
+          end
+        end
+        private_class_method :try_custom_normalize
+      end
+    end
+  end
+end

data/lib/sorbet/toon/encode/primitives.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+require_relative '../constants'
+require_relative '../shared/validation'
+require_relative '../shared/literal_utils'
+require_relative '../shared/string_utils'
+
+module Sorbet
+  module Toon
+    module Encode
+      module Primitives
+        module_function
+
+        def encode_primitive(value, delimiter = Constants::DEFAULT_DELIMITER)
+          case value
+          when nil
+            Constants::NULL_LITERAL
+          when TrueClass, FalseClass
+            value.to_s
+          when Integer
+            value.to_s
+          when Float
+            format_float(value)
+          when Numeric
+            value.to_s
+          else
+            encode_string_literal(value.to_s, delimiter)
+          end
+        end
+
+        def encode_string_literal(value, delimiter = Constants::DEFAULT_DELIMITER)
+          if Shared::Validation.safe_unquoted?(value, delimiter)
+            value
+          else
+            "\"#{Shared::StringUtils.escape_string(value)}\""
+          end
+        end
+
+        def encode_key(key)
+          if Shared::Validation.valid_unquoted_key?(key)
+            key
+          else
+            "\"#{Shared::StringUtils.escape_string(key)}\""
+          end
+        end
+
+        def encode_and_join_primitives(values, delimiter = Constants::DEFAULT_DELIMITER)
+          values.map { |v| encode_primitive(v, delimiter) }.join(delimiter)
+        end
+
+        def format_header(length, key: nil, fields: nil, delimiter: Constants::DEFAULT_DELIMITER, length_marker: false)
+          header = +''
+          header << encode_key(key) if key
+
+          header << '['
+          header << Constants::HASH if length_marker == Constants::HASH
+          header << length.to_i.to_s
+          header << delimiter if delimiter != Constants::DEFAULT_DELIMITER
+          header << ']'
+
+          if fields && !fields.empty?
+            encoded_fields = fields.map { |field| encode_key(field) }
+            header << '{'
+            header << encoded_fields.join(delimiter)
+            header << '}'
+          end
+
+          header << Constants::COLON
+          header
+        end
+
+        def format_float(value)
+          return '0' if value.zero?
+
+          decimal = BigDecimal(value.to_s)
+          str = decimal.to_s('F')
+          str = str.sub(/\.0+\z/, '')
+          str.sub(/(\.\d*?)0+\z/, '\1')
+        end
+        private_class_method :format_float
+      end
+    end
+  end
+end

data/lib/sorbet/toon/encode/writer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+
+module Sorbet
+  module Toon
+    module Encode
+      class Writer
+        def initialize(indent_size)
+          @indentation_string = Constants::SPACE * indent_size
+          @lines = []
+        end
+
+        def push(depth, content)
+          @lines << "#{@indentation_string * depth}#{content}"
+        end
+
+        def push_list_item(depth, content)
+          push(depth, "#{Constants::LIST_ITEM_PREFIX}#{content}")
+        end
+
+        def to_s
+          @lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/sorbet/toon/encoder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'normalizer'
+require_relative 'codec'
+
+module Sorbet
+  module Toon
+    module Encoder
+      CONFIG_KEYS = %i[indent delimiter length_marker include_type_metadata].freeze
+
+      class << self
+        def encode(value, config:, signature: nil, role: :output, **overrides)
+          config_overrides = extract_overrides(overrides, CONFIG_KEYS)
+          resolved = config.resolve(config_overrides)
+
+          normalized = Sorbet::Toon::Normalizer.normalize(
+            value,
+            signature: signature,
+            role: role,
+            include_type_metadata: resolved.include_type_metadata
+          )
+
+          Sorbet::Toon::Codec.encode(
+            normalized,
+            indent: resolved.indent,
+            delimiter: resolved.delimiter,
+            length_marker: resolved.length_marker
+          )
+        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

data/lib/sorbet/toon/enum_extensions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sorbet
+  module Toon
+    module EnumExtensions
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def from_toon(payload, **options)
+          value = Sorbet::Toon.decode(payload, **options)
+          return value if value.is_a?(self)
+
+          if respond_to?(:deserialize)
+            deserialize(value)
+          else
+            values.find { |member| member.serialize == value }
+          end
+        end
+      end
+
+      def to_toon(**options)
+        Sorbet::Toon.encode(serialize, **options)
+      end
+    end
+  end
+end

data/lib/sorbet/toon/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sorbet
+  module Toon
+    class Error < StandardError; end
+
+    class DecodeError < Error; end
+    class EncodeError < Error; end
+  end
+end

data/lib/sorbet/toon/normalizer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'sorbet-runtime'
+
+require_relative 'errors'
+
+module Sorbet
+  module Toon
+    module Normalizer
+      class << self
+        def normalize(value, signature: nil, role: :output, include_type_metadata: false)
+          context = {
+            signature: signature,
+            role: role,
+            include_type_metadata: include_type_metadata
+          }
+
+          normalize_value(value, context)
+        end
+
+        private
+
+        def normalize_value(value, context)
+          return nil if value.nil?
+
+          case value
+          when T::Struct
+            normalize_struct(value, context)
+          when T::Enum
+            value.serialize
+          when Array
+            value.map { |item| normalize_value(item, context) }
+          when Set
+            value.map { |item| normalize_value(item, context) }
+          when Hash
+            normalize_hash(value, context)
+          else
+            normalize_primitive(value)
+          end
+        end
+
+        def normalize_struct(struct, context)
+          result = {}
+          if context[:include_type_metadata]
+            result['_type'] = type_label_for(struct.class)
+          end
+
+          struct.class.props.each do |prop_name, prop_info|
+            prop_value = struct.send(prop_name)
+            next if prop_value.nil? && prop_info[:fully_optional]
+
+            result[prop_name.to_s] = normalize_value(prop_value, context)
+          end
+
+          result
+        end
+
+        def normalize_hash(hash, context)
+          hash.each_with_object({}) do |(key, value), memo|
+            memo[key_to_string(key)] = normalize_value(value, context)
+          end
+        end
+
+        def normalize_primitive(value)
+          case value
+          when Float
+            return nil unless value.finite?
+            return 0.0 if value.zero?
+
+            value
+          else
+            if value.respond_to?(:serialize)
+              value.serialize
+            else
+              value
+            end
+          end
+        end
+
+        def key_to_string(key)
+          key.to_s
+        end
+
+        def type_label_for(klass)
+          return 'AnonymousStruct' if klass.name.nil? || klass.name.empty?
+
+          klass.name.split('::').last
+        end
+      end
+    end
+  end
+end