cton 0.4.0 → 1.0.0

data/sig/cton/schema.rbs

@@ -0,0 +1,84 @@
+module Cton
+  module Schema
+    class Error
+      attr_reader path: String
+      attr_reader message: String
+      attr_reader expected: String?
+      attr_reader actual: String?
+
+      def initialize: (path: String, message: String, ?expected: String?, ?actual: String?) -> void
+      def to_s: -> String
+      def to_h: -> Hash[Symbol, untyped]
+    end
+
+    class Result
+      attr_reader errors: Array[Error]
+
+      def initialize: (?Array[Error] errors) -> void
+      def valid?: -> bool
+      def to_s: -> String
+    end
+
+    class Node
+      def validate: (untyped value, String path, Array[Error] errors) -> void
+    end
+
+    class AnySchema < Node
+    end
+
+    class NullableSchema < Node
+      def initialize: (Node inner) -> void
+    end
+
+    class OptionalSchema < Node
+      def initialize: (Node inner) -> void
+    end
+
+    class ScalarSchema < Node
+      def initialize: (?types: Array[Class], ?enum: Array[untyped]) -> void
+    end
+
+    class ObjectSchema < Node
+      def initialize: (required: Hash[String, Node], optional: Hash[String, Node], ?allow_extra: bool) -> void
+    end
+
+    class ArraySchema < Node
+      def initialize: (item_schema: Node?, ?length: Integer?, ?min: Integer?, ?max: Integer?) -> void
+    end
+
+    module DSL
+      def object: (?allow_extra: bool) { () -> untyped } -> ObjectSchema
+      def array: (?length: Integer?, ?min: Integer?, ?max: Integer?, ?of: Node?) { () -> untyped } -> ArraySchema
+      def nullable: (Node schema) -> NullableSchema
+      def optional: (Node schema) -> OptionalSchema
+      def any: -> AnySchema
+      def scalar: (*untyped types, ?enum: Array[untyped]) -> ScalarSchema
+      def enum: (*untyped values) -> ScalarSchema
+      def string: -> ScalarSchema
+      def integer: -> ScalarSchema
+      def float: -> ScalarSchema
+      def number: -> ScalarSchema
+      def boolean: -> ScalarSchema
+      def null: -> ScalarSchema
+    end
+
+    class Builder
+      include DSL
+    end
+
+    class ObjectBuilder < Builder
+      def key: (String name, ?Node schema) { () -> untyped } -> void
+      def optional: (String name, ?Node schema) { () -> untyped } -> void
+      def allow_extra_keys!: -> void
+      def to_schema: -> ObjectSchema
+    end
+
+    class ArrayBuilder < Builder
+      def items: (?Node schema) { () -> untyped } -> void
+      def of: (?Node schema) { () -> untyped } -> void
+      def to_schema: -> ArraySchema
+    end
+
+    def self.define: { () -> Node } -> Node
+  end
+end

data/sig/cton/stream.rbs

@@ -0,0 +1,13 @@
+module Cton
+  class StreamReader
+    include Enumerable[untyped]
+
+    def initialize: (IO io, ?separator: String, ?symbolize_names: bool) -> void
+    def each: { (untyped) -> void } -> void
+  end
+
+  class StreamWriter
+    def initialize: (IO io, ?separator: String, **untyped) -> void
+    def write: (untyped value) -> void
+  end
+end

data/sig/cton.rbs

@@ -26,6 +26,12 @@ module Cton
   def self.unregister_type: (Class klass) -> void
   def self.clear_type_registry!: -> void
   def self.type_registry: -> TypeRegistry
+  def self.schema: { () -> Schema::Node } -> Schema::Node
+  def self.validate_schema: (untyped data, Schema::Node schema) -> Schema::Result
+  def self.load_stream: (IO io, ?separator: String, ?symbolize_names: bool) -> Enumerable[untyped]
+  def self.dump_stream: (Enumerable[untyped] enumerable, IO io, ?separator: String, **untyped) -> IO
+  def self.dump_binary: (untyped data, ?compress: bool, **untyped) -> String
+  def self.load_binary: (String binary) -> untyped
 
   class ValidationResult
     attr_reader errors: Array[ValidationError]
@@ -110,6 +116,7 @@ module Cton
     attr_reader indent_level: Integer
     attr_reader decimal_mode: Symbol
     attr_reader comments: Hash[String, String]
+    attr_reader buffer: String
 
     def encode_root: (untyped value) -> void
     def encode_top_level_pair: (String | Symbol key, untyped value) -> void
@@ -139,6 +146,9 @@ module Cton
     def homogeneous_scalar_tokens?: (Array[untyped] list) -> bool
     def token_does_not_require_quotes?: (untyped value) -> bool
     def fast_scalar_stream: (Array[untyped] list) -> String
+    def buffer_for: -> String
+    def reset_buffer: -> void
+    def buffer_available?: -> bool
     def indent: -> void
     def outdent: -> void
     def newline: -> void
@@ -149,9 +159,14 @@ module Cton
     TERMINATORS: Array[String]
     KEY_VALUE_BOUNDARY_TOKENS: Array[String]
     SAFE_KEY_PATTERN: Regexp
+    SAFE_KEY_CHAR_PATTERN: Regexp
+    TERMINATOR_REGEX: Regexp
     INTEGER_PATTERN: Regexp
     FLOAT_PATTERN: Regexp
 
+    def self.decode: (String cton, ?symbolize_names: bool) -> untyped
+    def self.scan_stream: (IO io, ?separator: String, ?symbolize_names: bool) -> Enumerable[untyped]
+
     def initialize: (?symbolize_names: bool) -> void
     def decode: (String cton) -> untyped
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cton
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-26 00:00:00.000000000 Z
+date: 2026-01-17 00:00:00.000000000 Z
 dependencies: []
 description: CTON provides a JSON-compatible, token-efficient text representation
   optimized for LLM prompts.
@@ -27,13 +27,19 @@ files:
 - Rakefile
 - bench/encode_decode_bench.rb
 - lib/cton.rb
+- lib/cton/binary.rb
 - lib/cton/decoder.rb
 - lib/cton/encoder.rb
+- lib/cton/schema.rb
 - lib/cton/stats.rb
+- lib/cton/stream.rb
 - lib/cton/type_registry.rb
 - lib/cton/validator.rb
 - lib/cton/version.rb
 - sig/cton.rbs
+- sig/cton/binary.rbs
+- sig/cton/schema.rbs
+- sig/cton/stream.rbs
 homepage: https://github.com/davidesantangelo/cton
 licenses:
 - MIT