smarter_json 0.9.2 → 1.0.0

data/lib/smarter_json/generator.rb

@@ -34,7 +34,17 @@ module SmarterJSON
     # (including multi-byte UTF-8) is emitted raw — valid JSON.
     ESCAPE_RE = /["\\\x00-\x1f]/.freeze
 
+    # Strict configuration: an unknown writer option is a caller bug, so it raises
+    # rather than being silently ignored.
+    KNOWN_OPTIONS = %i[format indent ascii_only script_safe sort_keys coerce allow_nan].freeze
+
     def initialize(options = {})
+      unknown = options.keys - KNOWN_OPTIONS
+      unless unknown.empty?
+        raise ArgumentError, "SmarterJSON.generate: unknown option#{unknown.size == 1 ? '' : 's'} " \
+                             "#{unknown.map(&:inspect).join(', ')} — valid keys: #{KNOWN_OPTIONS.map(&:inspect).join(', ')}"
+      end
+
       @format = options.fetch(:format, :json)
       unless %i[json ndjson].include?(@format)
         raise ArgumentError, "unknown writer format: #{@format.inspect} (expected :json or :ndjson)"
@@ -50,10 +60,11 @@ module SmarterJSON
 
       @pretty = @indent > 0
 
-      @ascii_only  = options.fetch(:ascii_only, false)  # escape non-ASCII as \uXXXX
-      @script_safe = options.fetch(:script_safe, false) # escape </ and U+2028 / U+2029
-      @sort_keys   = options.fetch(:sort_keys, false)   # emit object keys in sorted order
-      @coerce      = options.fetch(:coerce, false)      # convert unknown types via as_json / to_json
+      @ascii_only  = boolean_option(options, :ascii_only)  # escape non-ASCII as \uXXXX
+      @script_safe = boolean_option(options, :script_safe) # escape </ and U+2028 / U+2029
+      @sort_keys   = boolean_option(options, :sort_keys)   # emit object keys in sorted order
+      @coerce      = boolean_option(options, :coerce)      # convert unknown types via as_json / to_json
+      @allow_nan   = boolean_option(options, :allow_nan)   # emit NaN / Infinity / -Infinity (JSON5) instead of raising
       @escape_re   = build_escape_re
     end
 
@@ -77,7 +88,48 @@ module SmarterJSON
 
     private
 
-    def emit(obj, buf, level = 0)
+    # A boolean writer option must be exactly true or false — a wrong type is a
+    # caller bug, so it raises rather than being coerced or ignored.
+    def boolean_option(options, key)
+      value = options.fetch(key, false)
+      return value if value == true || value == false
+
+      raise ArgumentError, "#{key} must be true or false (got #{value.inspect})"
+    end
+
+    # Iterative serializer — an explicit frame stack (one frame per open container),
+    # mirroring the recursive structure but heap-allocated, so arbitrarily deep input
+    # cannot overflow the call stack (parity with the iterative parser). Output is
+    # byte-identical to the former recursive version. A frame is a small Array:
+    #   [members, idx, is_hash, before_first, before_rest, colon, closer, level]
+    def emit(obj, buf)
+      stack = []
+      push_value(obj, 0, buf, stack)
+      until stack.empty?
+        frame   = stack.last
+        members = frame[0]
+        i       = frame[1]
+        if i == members.length
+          buf << frame[6] # closer
+          stack.pop
+          next
+        end
+        frame[1] = i + 1
+        buf << (i.zero? ? frame[3] : frame[4]) # opener-pad / separator-pad
+        if frame[2] # hash
+          k, v = members[i]
+          emit_string(k.is_a?(String) ? k : k.to_s, buf) # Symbol/other keys -> string
+          buf << frame[5] # colon
+          push_value(v, frame[7] + 1, buf, stack)
+        else
+          push_value(members[i], frame[7] + 1, buf, stack)
+        end
+      end
+    end
+
+    # Emit one value at `level`: a scalar appends directly; a non-empty container writes
+    # its opener and pushes a frame for the driver above to walk (no recursion into it).
+    def push_value(obj, level, buf, stack)
       case obj
       when nil        then buf << "null"
       when true       then buf << "true"
@@ -87,22 +139,30 @@ module SmarterJSON
       when Integer    then buf << obj.to_s
       when Float      then emit_float(obj, buf)
       when BigDecimal then emit_bigdecimal(obj, buf)
-      when Array      then emit_array(obj, buf, level)
-      when Hash       then emit_hash(obj, buf, level)
+      when Array
+        return buf << "[]" if obj.empty? # empty stays inline, even in pretty mode
+
+        buf << (@pretty ? "[\n" : "[")
+        stack << container_frame(obj, false, level)
+      when Hash
+        return buf << "{}" if obj.empty? # empty stays inline, even in pretty mode
+
+        pairs = @sort_keys ? obj.sort_by { |k, _| k.is_a?(String) ? k : k.to_s } : obj.to_a
+        buf << (@pretty ? "{\n" : "{")
+        stack << container_frame(pairs, true, level)
       else
-        return emit_coerced(obj, buf, level) if @coerce
+        return push_coerced(obj, level, buf, stack) if @coerce
 
         raise SmarterJSON::GenerateError, "SmarterJSON.generate cannot serialize #{obj.class}"
       end
     end
 
-    # coerce: true — let a value that isn't natively supported convert itself.
-    # Prefer as_json (its result is re-emitted through the normal pipeline, so the
-    # escaping/format options still apply); fall back to to_json (spliced as-is, so
-    # ascii_only / script_safe do not reach inside it). Raise if it defines neither.
-    def emit_coerced(obj, buf, level)
+    # coerce: true — prefer as_json (re-emitted through the normal pipeline, so the
+    # escaping/format options still apply); else to_json (spliced as-is, so ascii_only /
+    # script_safe do not reach inside it); else raise.
+    def push_coerced(obj, level, buf, stack)
       if obj.respond_to?(:as_json)
-        emit(obj.as_json, buf, level)
+        push_value(obj.as_json, level, buf, stack)
       elsif obj.respond_to?(:to_json)
         buf << obj.to_json
       else
@@ -110,57 +170,16 @@ module SmarterJSON
       end
     end
 
-    def emit_array(arr, buf, level)
-      return buf << "[]" if arr.empty? # empty stays inline, even in pretty mode
-
-      if @pretty
-        pad = " " * (@indent * (level + 1))
-        buf << "[\n"
-        arr.each_with_index do |v, i|
-          buf << ",\n" unless i.zero?
-          buf << pad
-          emit(v, buf, level + 1)
-        end
-        buf << "\n" << (" " * (@indent * level)) << "]"
-      else
-        buf << "["
-        arr.each_with_index do |v, i|
-          buf << "," unless i.zero?
-          emit(v, buf, level)
-        end
-        buf << "]"
-      end
-    end
-
-    def emit_hash(hash, buf, level)
-      return buf << "{}" if hash.empty? # empty stays inline, even in pretty mode
-
-      pairs = @sort_keys ? hash.sort_by { |k, _| k.is_a?(String) ? k : k.to_s } : hash
-
+    # Build a frame for an open container at `level`, precomputing its punctuation/indent
+    # once (as the recursive version computed `pad` once per container).
+    def container_frame(members, is_hash, level)
+      close_glyph = is_hash ? "}" : "]"
       if @pretty
-        pad = " " * (@indent * (level + 1))
-        buf << "{\n"
-        first = true
-        pairs.each do |k, v|
-          buf << ",\n" unless first
-          first = false
-          buf << pad
-          emit_string(k.is_a?(String) ? k : k.to_s, buf) # Symbol/other keys -> string
-          buf << ": "
-          emit(v, buf, level + 1)
-        end
-        buf << "\n" << (" " * (@indent * level)) << "}"
+        pad  = " " * (@indent * (level + 1))
+        padl = " " * (@indent * level)
+        [members, 0, is_hash, pad, ",\n#{pad}", ": ", "\n#{padl}#{close_glyph}", level]
       else
-        buf << "{"
-        first = true
-        pairs.each do |k, v|
-          buf << "," unless first
-          first = false
-          emit_string(k.is_a?(String) ? k : k.to_s, buf) # Symbol/other keys -> string
-          buf << ":"
-          emit(v, buf, level)
-        end
-        buf << "}"
+        [members, 0, is_hash, "", ",", ":", close_glyph, level]
       end
     end
 
@@ -195,15 +214,31 @@ module SmarterJSON
     end
 
     def emit_float(flt, buf)
-      raise SmarterJSON::GenerateError, "SmarterJSON.generate cannot serialize non-finite Float #{flt}" unless flt.finite?
+      unless flt.finite?
+        raise SmarterJSON::GenerateError, "SmarterJSON.generate cannot serialize non-finite Float #{flt}" unless @allow_nan
+
+        return buf << non_finite_literal(flt)
+      end
 
       buf << flt.to_s # Ruby's Float#to_s is shortest round-trippable; e-notation is valid JSON
     end
 
     def emit_bigdecimal(num, buf)
-      raise SmarterJSON::GenerateError, "SmarterJSON.generate cannot serialize non-finite BigDecimal" unless num.finite?
+      unless num.finite?
+        raise SmarterJSON::GenerateError, "SmarterJSON.generate cannot serialize non-finite BigDecimal" unless @allow_nan
+
+        return buf << non_finite_literal(num)
+      end
 
       buf << num.to_s("F") # plain decimal notation (BigDecimal's default "0.1e1" is not valid JSON)
     end
+
+    # JSON5-style literals for non-finite numbers, emitted only when allow_nan: true.
+    # `infinite?` returns 1 / -1 / nil for both Float and BigDecimal.
+    def non_finite_literal(num)
+      return "NaN" if num.nan?
+
+      num.infinite? == 1 ? "Infinity" : "-Infinity"
+    end
   end
 end

data/lib/smarter_json/options.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SmarterJSON
+  # All reader settings live in one options hash (smarter_csv style). This module
+  # holds the defaults, merges the caller's overrides onto them, and validates the
+  # result — mirroring SmarterCSV::Reader::Options.
+  module Options
+    DEFAULT_OPTIONS = {
+      acceleration: true,        # use the C extension when available; false forces pure Ruby
+      encoding: nil,             # label the input's encoding (no transcoding); nil keeps the input's own (valid-UTF-8 ASCII-8BIT → UTF-8)
+      symbolize_keys: false,     # Symbol keys instead of String
+      duplicate_key: :last_wins, # :last_wins | :first_wins  (repeats are also reported via on_warning)
+      decimal_precision: :auto,  # :auto | :float | :bigdecimal  (Oj-compatible decimal handling)
+      on_warning: nil,           # a callable invoked once per non-fatal lenient fix (a SmarterJSON::Warning)
+    }.freeze
+
+    module_function
+
+    # Merge the caller's overrides onto the defaults, validate, and return the hash.
+    def process_options(given_options = {})
+      options = DEFAULT_OPTIONS.merge(given_options || {})
+      validate_options!(options)
+      options
+    end
+
+    # Raise ArgumentError (consistent with the generator's option checks) listing
+    # every problem at once. Configuration is strict — unlike the lenient *data*
+    # handling, an unknown option key or a bad value raises, so a caller's typo or
+    # wrong type is caught immediately instead of silently having no effect.
+    def validate_options!(options)
+      errors = []
+
+      unknown = options.keys - DEFAULT_OPTIONS.keys
+      unless unknown.empty?
+        errors << "unknown option#{unknown.size == 1 ? '' : 's'} #{unknown.map(&:inspect).join(', ')} " \
+                  "— valid keys: #{DEFAULT_OPTIONS.keys.map(&:inspect).join(', ')}"
+      end
+
+      unless %i[auto float bigdecimal].include?(options[:decimal_precision])
+        errors << "decimal_precision must be :auto, :float, or :bigdecimal (got #{options[:decimal_precision].inspect})"
+      end
+      unless %i[last_wins first_wins].include?(options[:duplicate_key])
+        errors << "duplicate_key must be :last_wins or :first_wins (got #{options[:duplicate_key].inspect})"
+      end
+      unless [true, false].include?(options[:acceleration])
+        errors << "acceleration must be true or false (got #{options[:acceleration].inspect})"
+      end
+      unless [true, false].include?(options[:symbolize_keys])
+        errors << "symbolize_keys must be true or false (got #{options[:symbolize_keys].inspect})"
+      end
+      on_warning = options[:on_warning]
+      unless on_warning.nil? || on_warning.respond_to?(:call)
+        errors << "on_warning must be nil or a callable (got #{on_warning.class})"
+      end
+      encoding = options[:encoding]
+      unless encoding.nil? || encoding.is_a?(String)
+        errors << "encoding must be nil or a String (got #{encoding.class})"
+      end
+
+      raise ArgumentError, "SmarterJSON: invalid options — #{errors.join('; ')}" if errors.any?
+
+      options
+    end
+  end
+end