smarter_json 0.5.1

data/docs/options.md

@@ -0,0 +1,58 @@
+
+### Contents
+
+  * [Introduction](./_introduction.md)
+  * [The Basic Read API](./basic_read_api.md)
+  * [The Basic Write API](./basic_write_api.md)
+  * [**Configuration Options**](./options.md)
+  * [Examples](./examples.md)
+
+--------------
+
+# Configuration Options
+
+## Reading
+
+These options are passed to [`SmarterJSON.process`](./basic_read_api.md) and `SmarterJSON.process_file` as the second argument; anything you set overrides the defaults below.
+
+| Option            | Default      | Explanation                                                                                                            |
+|-------------------|--------------|------------------------------------------------------------------------------------------------------------------------|
+| `:symbolize_keys` | `false`      | Return object keys as Symbols instead of Strings.                                                                      |
+| `:duplicate_key`  | `:last_wins` | How to handle a key that repeats within one object: `:last_wins`, `:first_wins`, or `:raise`.                          |
+| `:bigdecimal_load`| `:auto`      | `:auto` keeps high-precision decimals as `BigDecimal` (matches Oj); `:float` forces every number to `Float`; `:bigdecimal` forces every decimal to `BigDecimal`. |
+| `:acceleration`   | `true`       | Use the C extension when it is compiled and loadable; `false` forces the pure-Ruby parser. Both produce identical results. |
+| `:encoding`       | `nil`        | Labels the input's encoding (e.g. `"UTF-8"`). It does **not** trigger a transcoding pass — see below.                  |
+
+```ruby
+SmarterJSON.process('{"a": 1}', symbolize_keys: true)               # => {:a=>1}
+SmarterJSON.process('{"a":1,"a":2}', duplicate_key: :raise)         # raises SmarterJSON::ParseError
+SmarterJSON.process(big_decimal_json, bigdecimal_load: :float)      # every number as Float (fastest)
+```
+
+### A note on `:encoding`
+
+`:encoding` labels what the input *is* — it does not transcode. The parser works on the bytes in their native encoding and emits string values with the same encoding tag, the same way `smarter_csv` handles encodings. Bytes that are invalid for the claimed encoding raise `SmarterJSON::EncodingError` (a kind of `SmarterJSON::ParseError`). A UTF-8 BOM is handled automatically; UTF-16 / UTF-32 input is out of scope.
+
+### A note on `:bigdecimal_load`
+
+The default `:auto` preserves high-precision numbers as `BigDecimal`, matching Oj's default. That is intrinsically slower than producing `Float` on number-heavy files (e.g. `canada.json`). For raw speed when you don't need the extra precision, pass `bigdecimal_load: :float`.
+
+## Writing
+
+This option is passed to [`SmarterJSON.generate`](./basic_write_api.md) as the second argument.
+
+| Option     | Default | Explanation                                                                                                                |
+|------------|---------|-----------------------------------------------------------------------------------------------------------------------------|
+| `:format`  | `:json` | `:json` writes standard JSON (Hash → object, Array → array, scalar → scalar). `:ndjson` writes newline-delimited JSON: an Array becomes one element per line, any other value becomes a single line. |
+
+Any other `:format` value raises `ArgumentError`.
+
+```ruby
+SmarterJSON.generate([1, 2, 3])                          # => "[1,2,3]"   (default :json — a single JSON array)
+SmarterJSON.generate([1, 2, 3], format: :ndjson)         # => "1\n2\n3\n" (one element per line)
+SmarterJSON.generate({}, format: :bogus)                 # raises ArgumentError
+```
+
+---------------
+
+PREVIOUS: [The Basic Write API](./basic_write_api.md) | NEXT: [Examples](./examples.md) | UP: [README](../README.md)

data/ext/smarter_json/extconf.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rbconfig"
+
+# Ruby sometimes ships CFLAGS with "-g -O3"; drop the debug half so the
+# extension is built optimized, not with debug info.
+if RbConfig::MAKEFILE_CONFIG["CFLAGS"].include?("-g -O3")
+  RbConfig::MAKEFILE_CONFIG["CFLAGS"] = RbConfig::MAKEFILE_CONFIG["CFLAGS"].sub("-g -O3", "-O3 $(cflags)")
+end
+
+optflags = "-O3 -flto -fomit-frame-pointer -DNDEBUG".dup
+# -march=native is skipped on arm64-darwin (Apple clang already targets the host).
+optflags << " -march=native" unless RUBY_PLATFORM.start_with?("arm64-darwin")
+# -fno-semantic-interposition: GCC/Clang only (not MSVC).
+optflags << " -fno-semantic-interposition" unless RUBY_PLATFORM.include?("mswin")
+
+CONFIG["optflags"]   = optflags
+CONFIG["debugflags"] = ""
+
+# rb_enc_interned_str (Ruby 3.0+) lets us intern object keys straight from the
+# input bytes; on older Rubies the C code falls back to a plain new string.
+have_func("rb_enc_interned_str", "ruby.h")
+
+# Pre-sized hashes (3.2+) and bulk insert (2.6+) for object building; the C code
+# falls back to rb_hash_new + per-pair aset when these are unavailable.
+have_func("rb_hash_new_capa", "ruby.h")
+have_func("rb_hash_bulk_insert", "ruby.h")
+
+create_makefile("smarter_json/smarter_json")