cton 0.1.1 → 0.3.0

data/lib/cton/encoder.rb

@@ -1,27 +1,35 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "time"
+require "date"
 
 module Cton
   class Encoder
-    SAFE_TOKEN = /\A[0-9A-Za-z_.:-]+\z/.freeze
-    NUMERIC_TOKEN = /\A-?(?:\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?\z/.freeze
+    SAFE_TOKEN = /\A[0-9A-Za-z_.:-]+\z/
+    NUMERIC_TOKEN = /\A-?(?:\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?\z/
     RESERVED_LITERALS = %w[true false null].freeze
     FLOAT_DECIMAL_PRECISION = Float::DIG
 
-    def initialize(separator: "\n")
+    def initialize(separator: "\n", pretty: false, decimal_mode: :fast)
       @separator = separator || ""
+      @pretty = pretty
+      @decimal_mode = decimal_mode
+      raise ArgumentError, "decimal_mode must be :fast or :precise" unless %i[fast precise].include?(@decimal_mode)
+
+      @indent_level = 0
+      @table_schema_cache = {}
     end
 
-    def encode(payload)
-      @io = StringIO.new
+    def encode(payload, io: nil)
+      @io = io || StringIO.new
       encode_root(payload)
-      @io.string
+      @io.string if @io.is_a?(StringIO)
     end
 
     private
 
-    attr_reader :separator, :io
+    attr_reader :separator, :io, :pretty, :indent_level, :decimal_mode
 
     def encode_root(value)
       case value
@@ -43,6 +51,12 @@ module Cton
     end
 
     def encode_value(value, context:)
+      if defined?(Set) && value.is_a?(Set)
+        value = value.to_a
+      elsif defined?(OpenStruct) && value.is_a?(OpenStruct)
+        value = value.to_h
+      end
+
       case value
       when Hash
         encode_object(value)
@@ -61,13 +75,19 @@ module Cton
       end
 
       io << "("
+      indent if pretty
       first = true
       hash.each do |key, value|
-        io << "," unless first
+        if first
+          first = false
+        else
+          io << ","
+          newline if pretty
+        end
         io << format_key(key) << "="
         encode_value(value, context: :object)
-        first = false
       end
+      outdent if pretty
       io << ")"
     end
 
@@ -80,8 +100,8 @@ module Cton
 
       io << "[" << length.to_s << "]"
 
-      if table_candidate?(list)
-        encode_table(list)
+      if (header = table_schema_for(list))
+        encode_table(list, header)
       else
         io << "="
         if list.all? { |value| scalar?(value) }
@@ -92,65 +112,102 @@ module Cton
       end
     end
 
-    def encode_table(rows)
-      header = rows.first.keys
+    def encode_table(rows, header)
       io << "{"
       io << header.map { |key| format_key(key) }.join(",")
       io << "}="
 
+      indent if pretty
       first_row = true
       rows.each do |row|
-        io << ";" unless first_row
+        if first_row
+          first_row = false
+        else
+          io << ";"
+          newline if pretty
+        end
+
         first_col = true
         header.each do |field|
           io << "," unless first_col
           encode_scalar(row.fetch(field))
           first_col = false
         end
-        first_row = false
       end
+      outdent if pretty
     end
 
     def encode_scalar_list(list)
-      first = true
-      list.each do |value|
-        io << "," unless first
-        encode_scalar(value)
-        first = false
+      if pretty
+        indent
+        first = true
+        list.each do |value|
+          if first
+            first = false
+          else
+            io << ","
+            newline
+          end
+          encode_scalar(value)
+        end
+        outdent
+      else
+        first = true
+        if fast_scalar_stream?(list)
+          io << fast_scalar_stream(list)
+        else
+          list.each do |value|
+            io << "," unless first
+            encode_scalar(value)
+            first = false
+          end
+        end
       end
     end
 
     def encode_mixed_list(list)
+      indent if pretty
       first = true
       list.each do |value|
-        io << "," unless first
+        if first
+          first = false
+        else
+          io << ","
+          newline if pretty
+        end
         encode_value(value, context: :array)
-        first = false
       end
+      outdent if pretty
     end
 
     def encode_scalar(value)
+      io << scalar_to_string(value)
+    end
+
+    def scalar_to_string(value)
       case value
       when String
-        encode_string(value)
+        format_string(value)
       when TrueClass, FalseClass
-        io << (value ? "true" : "false")
+        value ? "true" : "false"
       when NilClass
-        io << "null"
+        "null"
       when Numeric
-        io << format_number(value)
+        format_number(value)
+      when Time, Date
+        format_string(value.iso8601)
       else
         raise EncodeError, "Unsupported value: #{value.class}"
       end
     end
 
-    def encode_string(value)
+    def format_string(value)
       if value.empty?
-        io << '""'
+        '""'
       elsif string_needs_quotes?(value)
-        io << quote_string(value)
+        quote_string(value)
       else
-        io << value
+        value
       end
     end
 
@@ -172,7 +229,7 @@ module Cton
     end
 
     def normalize_decimal_string(string)
-      stripped = string.start_with?("+") ? string[1..-1] : string
+      stripped = string.start_with?("+") ? string[1..] : string
       return "0" if zero_string?(stripped)
 
       if stripped.include?(".")
@@ -188,6 +245,17 @@ module Cton
     end
 
     def float_decimal_string(value)
+      return precise_float_decimal_string(value) if decimal_mode == :precise
+
+      decimal = value.to_s
+      if decimal.include?("e") || decimal.include?("E")
+        precise_float_decimal_string(value)
+      else
+        decimal
+      end
+    end
+
+    def precise_float_decimal_string(value)
       if defined?(BigDecimal)
         BigDecimal(value.to_s).to_s("F")
       else
@@ -197,14 +265,14 @@ module Cton
 
     def format_key(key)
       key_string = key.to_s
-      unless SAFE_TOKEN.match?(key_string)
-        raise EncodeError, "Invalid key: #{key_string.inspect}"
-      end
+      raise EncodeError, "Invalid key: #{key_string.inspect}" unless SAFE_TOKEN.match?(key_string)
+
       key_string
     end
 
     def string_needs_quotes?(value)
       return true unless SAFE_TOKEN.match?(value)
+
       RESERVED_LITERALS.include?(value) || numeric_like?(value)
     end
 
@@ -229,19 +297,81 @@ module Cton
     end
 
     def scalar?(value)
-      value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false || value.nil?
+      value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false || value.nil? || value.is_a?(Time) || value.is_a?(Date)
+    end
+
+    def table_schema_for(rows)
+      cache_lookup = @table_schema_cache.fetch(rows.object_id, :__missing__)
+      return cache_lookup unless cache_lookup == :__missing__
+
+      schema = compute_table_schema(rows)
+      @table_schema_cache[rows.object_id] = schema
     end
 
-    def table_candidate?(rows)
-      return false if rows.empty?
+    def compute_table_schema(rows)
+      return nil if rows.empty?
 
       first = rows.first
-      return false unless first.is_a?(Hash) && !first.empty?
+      return nil unless first.is_a?(Hash) && !first.empty?
+
+      header = first.keys.freeze
 
-      keys = first.keys
-      rows.all? do |row|
-        row.is_a?(Hash) && row.keys == keys && row.values.all? { |val| scalar?(val) }
+      rows.each do |row|
+        return nil unless row.is_a?(Hash)
+        return nil unless row.keys == header
+        return nil unless row.values.all? { |val| scalar?(val) }
       end
+
+      header
+    end
+
+    def fast_scalar_stream?(list)
+      !pretty && list.length > 4 && homogeneous_scalar_tokens?(list)
+    end
+
+    def homogeneous_scalar_tokens?(list)
+      first_class = nil
+      list.all? do |value|
+        return false unless scalar?(value)
+
+        token_class = value.class
+        first_class ||= token_class
+        token_class == first_class && token_does_not_require_quotes?(value)
+      end
+    end
+
+    def token_does_not_require_quotes?(value)
+      case value
+      when String
+        !value.empty? && !string_needs_quotes?(value)
+      when Integer, TrueClass, FalseClass, NilClass
+        true
+      else
+        false
+      end
+    end
+
+    def fast_scalar_stream(list)
+      buffer = String.new
+      list.each_with_index do |value, index|
+        buffer << "," unless index.zero?
+        buffer << scalar_to_string(value)
+      end
+      buffer
+    end
+
+    def indent
+      @indent_level += 1
+      newline
+    end
+
+    def outdent
+      @indent_level -= 1
+      newline
+    end
+
+    def newline
+      io << "\n" << ("  " * indent_level)
     end
   end
 end

data/lib/cton/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cton
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/cton.rb

@@ -12,9 +12,24 @@ module Cton
 
   module_function
 
-  def dump(payload, options = {})
+  def dump(payload, *args)
+    io = nil
+    options = {}
+
+    args.each do |arg|
+      if arg.is_a?(Hash)
+        options.merge!(arg)
+      else
+        io = arg
+      end
+    end
+
+    io ||= options[:io]
+
     separator = options.fetch(:separator, "\n")
-    Encoder.new(separator: separator).encode(payload)
+    pretty = options.fetch(:pretty, false)
+    decimal_mode = options.fetch(:decimal_mode, :fast)
+    Encoder.new(separator: separator, pretty: pretty, decimal_mode: decimal_mode).encode(payload, io: io)
   end
   alias generate dump
 
@@ -23,4 +38,3 @@ module Cton
   end
   alias parse load
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cton
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-18 00:00:00.000000000 Z
+date: 2025-11-20 00:00:00.000000000 Z
 dependencies: []
 description: CTON provides a JSON-compatible, token-efficient text representation
   optimized for LLM prompts.
@@ -25,6 +25,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bench/encode_decode_bench.rb
 - lib/cton.rb
 - lib/cton/decoder.rb
 - lib/cton/encoder.rb
@@ -37,6 +38,7 @@ metadata:
   homepage_uri: https://github.com/davidesantangelo/cton
   source_code_uri: https://github.com/davidesantangelo/cton
   changelog_uri: https://github.com/davidesantangelo/cton/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: