tson-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab9797aad5299284b15b608b94cefe990caabe0d52ff23bff87c900c6d659aab
+  data.tar.gz: f7708ca210d62d67026e5d3dd17a0be76af10d696854093c431bd7fbabf10bcf
+SHA512:
+  metadata.gz: f789a1dc7c86cfd3899b627f9739d28fedd749398ebd73cb63d2bada7b872664bac7926dea8e517e8ad5dd5a96bf58692400cc2e46842fd484195629593f1956
+  data.tar.gz: 46f449190bbd53c75c6bc36dc82342ca710b772217e0ffa305ab08b0b1c4a365b7999af519cf8ebf35fa80805bdcf01d0cd56027b05d54ea713bb493f1182583

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lef237
+
+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,100 @@
+# tson-rails
+
+`tson-rails` renders Rails responses in the text format of [TSON](https://github.com/litterat/tson-io) (Typed Schema Object Notation).
+It implements the schemaless data layer of the TSON 2026 revision 32 Text Data Format that is needed for Rails data output.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "tson-rails"
+```
+
+After restarting the application, the gem registers `application/tson` and the `.tn1` extension, and `render tson:` becomes available.
+
+## Rendering TSON from Rails
+
+```ruby
+class UsersController < ApplicationController
+  def index
+    render tson: User.order(:id), pretty: true
+  end
+end
+```
+
+Example output:
+
+```tson
+[
+  {
+    id: 1
+    name: Ada
+    created_at: !datetime "2026-08-09T12:34:56.000000000+09:00"
+  }
+]
+```
+
+The renderer accepts the same Active Model serialization options as `render json:`.
+
+```ruby
+render tson: @user, only: %i[id name], pretty: true
+```
+
+It also supports `respond_to` and MIME negotiation.
+
+```ruby
+respond_to do |format|
+  format.tson { render tson: User.all }
+  format.json { render json: User.all }
+end
+```
+
+The response Content-Type is `application/tson; charset=utf-8`.
+
+## Ruby API
+
+The encoder can also be used without Rails.
+
+```ruby
+require "tson_rails"
+
+TsonRails.encode(
+  id: 1,
+  name: "Ada",
+  active: true,
+  tags: ["ruby", "rails"]
+)
+# => "{id:1,name:Ada,active:true,tags:[ruby,rails]}"
+```
+
+Encoding rules:
+
+- Hashes with String or Symbol keys are emitted as TSON records (`{ key: value }`).
+- Hashes with other key types are emitted as TSON maps (`{ key => value }`).
+- Arrays are emitted as TSON arrays (`[value value]`); compact output uses commas between values.
+- `nil` becomes `null`, Ruby dates and times become `!date` or `!datetime`, and `BigDecimal` values remain numeric.
+- `TsonRails.absent` becomes the TSON absent sentinel `_`, which is distinct from `nil`.
+- Objects that provide `serializable_hash` (including Active Record and Active Model objects) are materialized and encoded recursively.
+
+```ruby
+TsonRails.encode({ id: 1, note: TsonRails.absent })
+# => "{id:1,note:_}"
+
+TsonRails.encode({ id: 1, note: TsonRails.absent }, omit_absent: true)
+# => "{id:1}"
+```
+
+Output is compact by default. Pass `pretty: true` to enable newlines and indentation. To explicitly encode hashes as maps, pass `hash_mode: :map`.
+
+## Scope
+
+This initial release is a TSON schemaless data-format encoder. It does not yet include TSON schema document loading, schema hash verification, automatic schema generation from type definitions, or a TSON parser. The specification is still a working draft, so compatibility should be reviewed when it is finalized as version 1.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake test
+```
+
+The implementation and tests are released under the MIT License.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << "lib"
+  task.libs << "test"
+  task.pattern = "test/**/*_test.rb"
+  task.verbose = true
+end
+
+task default: :test

data/lib/tson-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "tson_rails"

data/lib/tson_rails/absent.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TsonRails
+  # A value that is present in a container but intentionally has no value.
+  # This is distinct from nil, which is encoded as the TSON null value.
+  class Absent
+    def inspect
+      "TsonRails.absent"
+    end
+
+    alias_method :to_s, :inspect
+
+    private
+
+    def initialize
+    end
+  end
+
+  ABSENT = Absent.new.freeze
+
+  def self.absent
+    ABSENT
+  end
+end

data/lib/tson_rails/encoder.rb

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "time"
+
+module TsonRails
+  # Encodes Ruby values into the TSON text data format.
+  #
+  # The encoder intentionally targets the schemaless data-format layer. It
+  # emits records for string/symbol-keyed hashes, maps for other hashes, and
+  # built-in TSON annotations for Ruby temporal and exact numeric values.
+  class Encoder
+    SERIALIZATION_OPTION_KEYS = %i[only except methods include].freeze
+
+    SAFE_UNQUOTED = /\A[A-Za-z0-9_+.\-]+\z/.freeze
+    DECIMAL_DIGITS = "[0-9](?:_?[0-9])*"
+    DECIMAL_INTEGER = "(?:0|[1-9](?:_?[0-9])*)"
+    BASED_INTEGER = "(?:0[xX][0-9A-Fa-f](?:_?[0-9A-Fa-f])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)"
+    EXPONENT = "[eE][+-]?#{DECIMAL_DIGITS}"
+    FLOAT = "(?:(?:#{DECIMAL_DIGITS})?\.(?:#{DECIMAL_DIGITS})(?:#{EXPONENT})?|#{DECIMAL_DIGITS}#{EXPONENT})"
+    NUMBER_TOKEN = /\A[+-]?(?:#{DECIMAL_INTEGER}|#{BASED_INTEGER}|#{FLOAT})\z/.freeze
+    SPECIAL_FLOAT_TOKEN = /\A[+-]?\.(?:inf|infinity|nan)\z/.freeze
+
+    def initialize(options = {})
+      options = options.to_h
+
+      @pretty = !!options.fetch(:pretty, false)
+      @indent = options.fetch(:indent, "  ").to_s
+      @omit_absent = !!options.fetch(:omit_absent, false)
+      @hash_mode = (options[:hash_mode] || options[:map_mode] || :auto).to_sym
+      @time_precision = Integer(options.fetch(:time_precision, 9))
+      @serialization_options = serialization_options_for(options)
+      @active_path = {}
+
+      unless %i[auto record map].include?(@hash_mode)
+        raise ArgumentError, "hash_mode must be :auto, :record, or :map"
+      end
+
+      if @time_precision.negative? || @time_precision > 9
+        raise ArgumentError, "time_precision must be between 0 and 9"
+      end
+    end
+
+    def encode(value)
+      encode_value(value, 0)
+    end
+
+    private
+
+    def serialization_options_for(options)
+      explicit = options[:serialization_options]
+      return explicit.to_h unless explicit.nil?
+
+      options.each_with_object({}) do |(key, value), result|
+        result[key] = value if SERIALIZATION_OPTION_KEYS.include?(key.to_sym)
+      end
+    end
+
+    def encode_value(value, depth)
+      if serializable_object?(value)
+        return with_cycle_guard(value) do
+          encode_value(materialize(value), depth)
+        end
+      end
+
+      case value
+      when Hash
+        with_cycle_guard(value) { encode_hash(value, depth) }
+      when Array
+        with_cycle_guard(value) { encode_array(value, depth) }
+      when Absent
+        "_"
+      when NilClass
+        "null"
+      when TrueClass, FalseClass
+        value.to_s
+      when Integer
+        value.to_s
+      when Float
+        encode_float(value)
+      when BigDecimal
+        encode_big_decimal(value)
+      when Rational
+        typed_scalar("!rational", value.to_s)
+      when Complex
+        typed_scalar("!complex", encode_complex(value))
+      when DateTime
+        typed_scalar("!datetime", value.iso8601(@time_precision))
+      when Date
+        typed_scalar("!date", value.iso8601)
+      when String
+        encode_token(value)
+      when Symbol
+        encode_token(value.to_s)
+      when Time
+        typed_scalar("!datetime", value.iso8601(@time_precision))
+      else
+        raise UnsupportedTypeError,
+          "cannot encode #{value.class}; provide a Hash, Array, scalar, or serializable_hash"
+      end
+    end
+
+    def serializable_object?(value)
+      return false if value.is_a?(Hash) || value.is_a?(Array)
+      return false if value.is_a?(String) || value.is_a?(Symbol)
+      return false if value.is_a?(Numeric) || value.is_a?(Date) || value.is_a?(Time)
+      return false if value.is_a?(Absent)
+      return false if value.nil? || value.equal?(true) || value.equal?(false)
+
+      value.respond_to?(:serializable_hash) || value.respond_to?(:to_ary) || value.respond_to?(:to_h)
+    end
+
+    def materialize(value)
+      if value.respond_to?(:serializable_hash)
+        serialized = serializable_hash(value)
+        unless serialized.is_a?(Hash)
+          raise UnsupportedTypeError,
+            "#{value.class}#serializable_hash must return a Hash, got #{serialized.class}"
+        end
+        return serialized
+      end
+
+      if value.respond_to?(:to_ary)
+        array = value.to_ary
+        return array if array.is_a?(Array)
+      end
+
+      if value.respond_to?(:to_h)
+        hash = value.to_h
+        return hash if hash.is_a?(Hash)
+      end
+
+      raise UnsupportedTypeError,
+        "#{value.class}#to_ary or #to_h must return an Array or Hash"
+    end
+
+    def serializable_hash(value)
+      method = value.method(:serializable_hash)
+      method.arity == 0 ? method.call : method.call(@serialization_options)
+    end
+
+    def encode_hash(hash, depth)
+      if record_hash?(hash)
+        encode_record(hash, depth)
+      else
+        encode_map(hash, depth)
+      end
+    end
+
+    def record_hash?(hash)
+      return false if @hash_mode == :map
+      return true if hash.empty? && @hash_mode != :map
+
+      unless hash.keys.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+        return false if @hash_mode == :auto
+
+        raise InvalidMapKeyError, "record keys must be Strings or Symbols"
+      end
+
+      names = hash.keys.map { |key| normalized_key_text(key) }
+      unique = names.uniq.length == names.length
+      if @hash_mode == :auto
+        raise InvalidMapKeyError, "record keys must be unique after Unicode normalization" unless unique
+
+        return true
+      end
+
+      raise InvalidMapKeyError, "record keys must be unique after Unicode normalization" unless unique
+
+      true
+    end
+
+    def encode_record(hash, depth)
+      fields = hash.each_with_object([]) do |(key, value), result|
+        next if @omit_absent && value.is_a?(Absent)
+
+        name = encode_token(key.to_s)
+        encoded_value = encode_value(value, depth + 1)
+        result << if @pretty
+          "#{name}: #{encoded_value}"
+        else
+          "#{name}:#{encoded_value}"
+        end
+      end
+
+      render_collection("{", "}", fields, depth)
+    end
+
+    def encode_map(hash, depth)
+      seen_keys = {}
+      entries = hash.each_with_object([]) do |(key, value), result|
+        if key.is_a?(Absent)
+          raise InvalidMapKeyError, "the TSON absent sentinel cannot be used as a map key"
+        end
+        next if @omit_absent && value.is_a?(Absent)
+
+        key_identity = map_key_identity(key)
+        if seen_keys.key?(key_identity)
+          raise InvalidMapKeyError, "map keys are not unique after TSON encoding: #{key.inspect}"
+        end
+        seen_keys[key_identity] = true
+
+        encoded_key = encode_value(key, depth + 1)
+        encoded_value = encode_value(value, depth + 1)
+        result << if @pretty
+          "#{encoded_key} => #{encoded_value}"
+        else
+          "#{encoded_key}=>#{encoded_value}"
+        end
+      end
+
+      render_collection("{", "}", entries, depth)
+    end
+
+    def map_key_identity(value)
+      case value
+      when String
+        [:scalar, normalized_key_text(value)]
+      when Symbol
+        [:scalar, normalized_key_text(value)]
+      when NilClass
+        [:scalar, "null"]
+      when TrueClass, FalseClass
+        [:scalar, value.to_s]
+      when Integer
+        [:scalar, value.to_s]
+      when Float
+        [:scalar, encode_float(value)]
+      when BigDecimal
+        [:scalar, encode_big_decimal(value)]
+      when Array
+        with_cycle_guard(value) do
+          [:array, value.map { |element| map_key_identity(element) }]
+        end
+      when Hash
+        with_cycle_guard(value) { compound_map_key_identity(value) }
+      else
+        if serializable_object?(value)
+          with_cycle_guard(value) { map_key_identity(materialize(value)) }
+        else
+          [:encoded, encode_value(value, 0)]
+        end
+      end
+    end
+
+    def compound_map_key_identity(hash)
+      entries = hash.each_with_object([]) do |(key, value), result|
+        next if @omit_absent && value.is_a?(Absent)
+
+        result << if record_hash?(hash)
+          [normalized_key_text(key), map_key_identity(value)]
+        else
+          [map_key_identity(key), map_key_identity(value)]
+        end
+      end
+
+      [record_hash?(hash) ? :record : :map, entries]
+    end
+
+    def encode_array(array, depth)
+      values = array.map { |value| encode_value(value, depth + 1) }
+      render_collection("[", "]", values, depth)
+    end
+
+    def render_collection(open, close, values, depth)
+      return "#{open}#{close}" if values.empty?
+
+      if @pretty
+        inner = values.map { |value| "#{@indent * (depth + 1)}#{value}" }.join("\n")
+        "#{open}\n#{inner}\n#{@indent * depth}#{close}"
+      else
+        "#{open}#{values.join(",")}#{close}"
+      end
+    end
+
+    def encode_float(value)
+      return ".nan" if value.nan?
+
+      case value.infinite?
+      when 1 then ".inf"
+      when -1 then "-.inf"
+      else value.to_s
+      end
+    end
+
+    def encode_big_decimal(value)
+      case value.infinite?
+      when 1 then typed_scalar("!float64", ".inf")
+      when -1 then typed_scalar("!float64", "-.inf")
+      else
+        typed_or_plain_number(value.to_s("F"))
+      end
+    end
+
+    def encode_complex(value)
+      real = encode_complex_component(value.real)
+      imaginary = encode_complex_component(value.imag)
+      separator = imaginary.start_with?("-") ? "-" : "+"
+      magnitude = imaginary.delete_prefix("-").delete_prefix("+")
+
+      "#{real}#{separator}#{magnitude}i"
+    end
+
+    def encode_complex_component(value)
+      case value
+      when Integer
+        value.to_s
+      when Float
+        if value.nan? || value.infinite?
+          raise UnsupportedTypeError, "cannot encode a Complex with a non-finite component"
+        end
+
+        value.to_s
+      when BigDecimal
+        unless value.finite?
+          raise UnsupportedTypeError, "cannot encode a Complex with a non-finite component"
+        end
+
+        value.to_s("F")
+      else
+        raise UnsupportedTypeError,
+          "cannot encode a Complex with #{value.class} components without losing precision"
+      end
+    end
+
+    def typed_or_plain_number(token)
+      return typed_scalar("!float64", ".nan") if token.casecmp("NaN").zero?
+
+      token
+    end
+
+    def typed_scalar(annotation, token)
+      "#{annotation} #{encode_token(token)}"
+    end
+
+    def encode_token(value)
+      text = utf8_string(value)
+      safe_unquoted?(text) ? text : %("#{escape_token(text)}")
+    end
+
+    def utf8_string(value)
+      text = value.to_s
+      text.encode(Encoding::UTF_8)
+    rescue EncodingError => error
+      raise InvalidStringError, "cannot encode invalid UTF-8 string: #{error.message}"
+    end
+
+    def normalized_key_text(value)
+      utf8_string(value).unicode_normalize(:nfc)
+    end
+
+    def safe_unquoted?(text)
+      return false unless text.match?(SAFE_UNQUOTED)
+      return false if text.start_with?("_")
+      return false if text.include?("..")
+      return false if %w[null true false].include?(text)
+      return false if NUMBER_TOKEN.match?(text) || SPECIAL_FLOAT_TOKEN.match?(text)
+      return false if %w[- + .].include?(text)
+
+      true
+    end
+
+    def escape_token(text)
+      escaped = String.new(encoding: Encoding::UTF_8)
+
+      text.each_codepoint do |codepoint|
+        escaped << case codepoint
+        when 0x08 then "\\b"
+        when 0x09 then "\\t"
+        when 0x0A then "\\n"
+        when 0x0C then "\\f"
+        when 0x0D then "\\r"
+        when 0x22 then '\\"'
+        when 0x5C then "\\\\"
+        when 0x00..0x1F, 0x7F, 0x85, 0x2028, 0x2029
+          format("\\u%04X", codepoint)
+        else
+          codepoint.chr(Encoding::UTF_8)
+        end
+      end
+
+      escaped
+    end
+
+    def with_cycle_guard(value)
+      object_id = value.object_id
+      if @active_path.key?(object_id)
+        raise CircularReferenceError, "cannot encode cyclic value at #{value.class}"
+      end
+
+      @active_path[object_id] = true
+      yield
+    ensure
+      @active_path.delete(object_id) if object_id
+    end
+  end
+end

data/lib/tson_rails/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TsonRails
+  class Error < StandardError; end
+
+  class UnsupportedTypeError < Error; end
+
+  class CircularReferenceError < Error; end
+
+  class InvalidMapKeyError < Error; end
+
+  class InvalidStringError < Error; end
+end

data/lib/tson_rails/rails_integration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TsonRails
+  module RailsIntegration
+    def self.install!
+      register_mime_type
+      register_renderer
+    end
+
+    def self.register_mime_type
+      return if Mime::Type.lookup_by_extension(:tson)
+
+      Mime::Type.register(TsonRails::MIME_TYPE, :tson, [], [:tn1])
+    end
+
+    def self.register_renderer
+      return if ActionController::Renderers::RENDERERS.include?(:tson)
+
+      ActionController::Renderers.add :tson do |object, options|
+        self.content_type = Mime[:tson] if media_type.nil?
+        TsonRails.encode(object, options)
+      end
+    end
+  end
+end

data/lib/tson_rails/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller/metal/renderers"
+require "action_dispatch/http/mime_type"
+
+module TsonRails
+  class Railtie < Rails::Railtie
+    initializer "tson_rails.register_renderer" do
+      TsonRails::RailsIntegration.install!
+    end
+  end
+end

data/lib/tson_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TsonRails
+  VERSION = "0.1.0"
+end

data/lib/tson_rails.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "tson_rails/version"
+require_relative "tson_rails/error"
+require_relative "tson_rails/absent"
+require_relative "tson_rails/encoder"
+
+module TsonRails
+  MIME_TYPE = "application/tson"
+
+  def self.encode(value, options = {})
+    Encoder.new(options).encode(value)
+  end
+
+  def self.install!
+    require_relative "tson_rails/rails_integration"
+    RailsIntegration.install!
+  end
+end
+
+if defined?(Rails::Railtie)
+  require_relative "tson_rails/rails_integration"
+  require_relative "tson_rails/railtie"
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "minitest/autorun"
+require "tson_rails"
+require "tson-rails"

data/test/tson_rails/encoder_test.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class TsonRailsEncoderTest < Minitest::Test
+  SerializableUser = Struct.new(:id, :name) do
+    def serializable_hash(options = {})
+      values = { "id" => id, "name" => name }
+      only = Array(options[:only]).map(&:to_s) if options[:only]
+      only ? values.select { |key, _| only.include?(key) } : values
+    end
+  end
+
+  def test_encodes_a_rails_shaped_record
+    value = {
+      id: 1,
+      name: "Ada",
+      active: true,
+      deleted_at: nil,
+      tags: ["ruby", "rails"]
+    }
+
+    assert_equal(
+      "{id:1,name:Ada,active:true,deleted_at:null,tags:[ruby,rails]}",
+      TsonRails.encode(value)
+    )
+  end
+
+  def test_quotes_strings_that_would_change_meaning_or_break_lexing
+    value = {
+      "null" => "null",
+      "number" => "42",
+      "url" => "https://example.com/a?x=1",
+      "line" => "a\nb",
+      "_id" => "x"
+    }
+
+    assert_equal(
+      '{"null":"null",number:"42",url:"https://example.com/a?x=1",line:"a\\nb","_id":x}',
+      TsonRails.encode(value)
+    )
+  end
+
+  def test_encodes_non_string_keyed_hashes_as_maps
+    assert_equal "{1=>one,2=>two}", TsonRails.encode(1 => "one", 2 => "two")
+  end
+
+  def test_rejects_map_keys_that_become_textually_identical
+    assert_raises(TsonRails::InvalidMapKeyError) { TsonRails.encode("1" => "string", 1 => "integer") }
+    assert_raises(TsonRails::InvalidMapKeyError) { TsonRails.encode("name" => "string", :name => "symbol") }
+
+    string_key = { value: "1" }
+    integer_key = { value: 1 }
+    assert_raises(TsonRails::InvalidMapKeyError) do
+      TsonRails.encode(string_key => "string", integer_key => "integer")
+    end
+  end
+
+  def test_encodes_dates_times_and_special_floats
+    value = {
+      date: Date.new(2026, 8, 9),
+      time: Time.new(2026, 8, 9, 12, 34, 56, "+09:00"),
+      infinity: Float::INFINITY,
+      nan: Float::NAN,
+      negative_zero: -0.0
+    }
+
+    assert_equal(
+      '{date:!date 2026-08-09,time:!datetime "2026-08-09T12:34:56.000000000+09:00",infinity:.inf,nan:.nan,negative_zero:-0.0}',
+      TsonRails.encode(value)
+    )
+  end
+
+  def test_encodes_big_decimal_as_an_exact_number
+    assert_equal "!date 2026-08-09", TsonRails.encode(Date.new(2026, 8, 9))
+    assert_equal "123.45", TsonRails.encode(BigDecimal("123.4500"))
+  end
+
+  def test_encodes_complex_numbers_only_when_their_components_are_representable
+    assert_equal "!complex 1-2.5i", TsonRails.encode(Complex(1, -2.5))
+
+    error = assert_raises(TsonRails::UnsupportedTypeError) do
+      TsonRails.encode(Complex(Rational(1, 2), 1))
+    end
+    assert_match(/without losing precision/, error.message)
+  end
+
+  def test_encodes_ruby_absent_separately_from_nil
+    value = { present: TsonRails.absent, null_value: nil, items: [1, TsonRails.absent, 3] }
+
+    assert_equal "{present:_,null_value:null,items:[1,_,3]}", TsonRails.encode(value)
+    assert_equal "{null_value:null,items:[1,_,3]}", TsonRails.encode(value, omit_absent: true)
+  end
+
+  def test_supports_pretty_output
+    assert_equal(
+      "{\n  user: {\n    id: 1\n    name: Ada\n  }\n}",
+      TsonRails.encode({ user: { id: 1, name: "Ada" } }, pretty: true)
+    )
+  end
+
+  def test_uses_serializable_hash_and_passes_serialization_options
+    user = SerializableUser.new(1, "Ada")
+
+    assert_equal "{id:1,name:Ada}", TsonRails.encode(user)
+    assert_equal "{id:1}", TsonRails.encode(user, only: [:id])
+  end
+
+  def test_materializes_array_like_collections
+    collection = Object.new
+    collection.define_singleton_method(:to_ary) { [SerializableUser.new(1, "Ada")] }
+
+    assert_equal "[{id:1,name:Ada}]", TsonRails.encode(collection)
+  end
+
+  def test_rejects_cycles
+    value = []
+    value << value
+
+    assert_raises(TsonRails::CircularReferenceError) { TsonRails.encode(value) }
+  end
+
+  def test_rejects_record_and_map_keys_that_only_differ_by_unicode_normalization
+    composed = "\u00E9"
+    decomposed = "e\u0301"
+    value = { composed => 1, decomposed => 2 }
+
+    assert_raises(TsonRails::InvalidMapKeyError) { TsonRails.encode(value) }
+    assert_raises(TsonRails::InvalidMapKeyError) { TsonRails.encode(value, hash_mode: :map) }
+  end
+
+  def test_rejects_unsupported_objects
+    assert_raises(TsonRails::UnsupportedTypeError) { TsonRails.encode(Object.new) }
+  end
+end

data/test/tson_rails/rails_integration_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller"
+require "action_dispatch/testing/test_request"
+
+require_relative "../test_helper"
+
+TsonRails.install!
+
+class TsonRailsRailsIntegrationTest < Minitest::Test
+  def test_registers_the_tson_mime_type_and_renderer
+    assert_equal "application/tson", Mime[:tson].to_s
+    assert_equal Mime[:tson], Mime::Type.lookup_by_extension(:tn1)
+    assert_includes ActionController::Renderers::RENDERERS, :tson
+  end
+
+  def test_render_tson_returns_a_tson_response
+    controller_class = Class.new(ActionController::Base) do
+      def show
+        render tson: { id: 1, name: "Ada" }, pretty: true
+      end
+    end
+
+    request = ActionDispatch::TestRequest.create
+    status, headers, body = controller_class.action(:show).call(request.env)
+
+    assert_equal 200, status
+    assert_equal "application/tson; charset=utf-8", headers["content-type"]
+    assert_equal "{\n  id: 1\n  name: Ada\n}", body.body
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: tson-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- lef237
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: A Rails renderer and standalone Ruby encoder for the TSON text data format.
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/tson-rails.rb
+- lib/tson_rails.rb
+- lib/tson_rails/absent.rb
+- lib/tson_rails/encoder.rb
+- lib/tson_rails/error.rb
+- lib/tson_rails/rails_integration.rb
+- lib/tson_rails/railtie.rb
+- lib/tson_rails/version.rb
+- test/test_helper.rb
+- test/tson_rails/encoder_test.rb
+- test/tson_rails/rails_integration_test.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Render Rails data as Typed Schema Object Notation (TSON)
+test_files: []