json5-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54db9905ae19b2ec82f8db3fb27732ce3332b04daf7515918939fcabb5fe2170
+  data.tar.gz: '05096708a51dd8e323c174164d7fa03e09079a05e21254e96caf3d9d8863ef64'
+SHA512:
+  metadata.gz: 7c19286aaa870ced8fb58f3f5bf81214a0af14455ed30689f36e0dd47d373ab827b0aafe72c5c6b49f8b02a3cbaefbc5b7f8d874f8279f365ebb1958054691cd
+  data.tar.gz: 52ef17204f488be48a0d6b31773e2c65025337f76d24867a5582400376658784143b8271f22063ea38449cc69fb15f15d40d467394ef4e715b4e175e531d5608

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+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/NOTICE

@@ -0,0 +1,6 @@
+This project includes generated parser artifacts produced with Ibex 0.3.0.
+Ibex is used during development and is not a runtime dependency.
+
+UnicodeData-3.0.0.txt is Copyright © 1991-2000 Unicode, Inc. and is
+redistributed under the Unicode License V3 included in
+tool/unicode/UNICODE-LICENSE.txt.

data/README.md

@@ -0,0 +1,161 @@
+# json5-ruby
+
+`json5-ruby` is a Pure Ruby JSON5 1.0.0 parser. Its syntactic parser is
+generated from `grammar/json5.y` with Ibex 0.3.0; Ibex and ibex-runtime are
+development/build dependencies only.
+
+## Installation
+
+```ruby
+gem "json5-ruby"
+```
+
+## Usage
+
+```ruby
+require "json5"
+
+JSON5.parse(<<~JSON5)
+  {
+    unquoted: 'value',
+    hex: 0x2a,
+    values: [true, null,],
+  }
+JSON5
+# {"unquoted"=>"value", "hex"=>42, "values"=>[true, nil]}
+```
+
+The parser accepts comments, single-quoted strings, trailing commas,
+IdentifierName keys, hexadecimal numbers, `Infinity`, and `NaN`. Input must be
+a valid UTF-8 or US-ASCII Ruby `String`; other encodings are not implicitly
+transcoded.
+
+`JSON5.parse` returns Ruby values by default. Use `number_mode: :float` or
+`:lexeme`, `string_mode: :code_units` for exact UTF-16 code units, and
+`duplicate_keys: :first`, `:error`, or `:preserve` when the default last-value
+policy is not appropriate. Lone surrogates in values require code-unit mode or
+`parse_document`; `duplicate_keys: :preserve` also retains lone-surrogate
+member names as `JSON5::ECMAString` keys because Ruby UTF-8 strings cannot
+represent them losslessly.
+
+Set `warn_duplicate_keys: true` to emit `duplicate_key` diagnostics for
+duplicates discarded by the `:last` or `:first` policies.
+
+```ruby
+document = JSON5.parse_document("{ /* keep me */ answer: 0x2a, }")
+document.root.raw
+# "{ /* keep me */ answer: 0x2a, }"
+```
+
+`Document` nodes retain byte spans, raw lexemes, decoded code units, and
+leading/trailing trivia. Member nodes expose trivia before `:` and around the
+comma/closing separator; array nodes expose the corresponding element
+separator trivia. The source is copied and frozen by default.
+
+## Limits and diagnostics
+
+`JSON5::Limits.default` protects input size, nesting depth, string and number
+length, comment length, and container entries. Pass `limits:
+JSON5::Limits.unbounded` only for trusted input. Diagnostics can be collected in
+an array or sent to a callable; by default warnings are sent to `Warning.warn`.
+Unescaped U+2028 and U+2029 in strings produce diagnostics.
+
+The defaults are 64 MiB input, 512 nesting levels, 16 Mi UTF-16 string code
+units, 1 MiB number tokens, 16 MiB comments, and 10,000,000 entries per
+container. Construct `JSON5::Limits` with individual keyword overrides when an
+application needs a different boundary; a `nil` field disables that one limit.
+
+```ruby
+warnings = []
+JSON5.parse("'line\u2028separator'", diagnostics: warnings)
+warnings.first.code
+# "unescaped_line_separator_in_string"
+```
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+bundle exec rake generated
+bundle exec rake conformance
+bundle exec rake fuzz
+bundle exec rake security
+bundle exec rake package
+```
+
+`bundle exec rake release:check` runs all deterministic release gates above. The
+generated and conformance tasks are read-only: intentional updates use
+`bundle exec rake generated:update` and `bundle exec rake conformance:update`,
+followed by the corresponding read-only check. `rake generated` regenerates into
+a temporary directory, runs Ibex's own `--check` against that raw output, then
+compares the canonicalized parser, manifest, automaton, verifier report, metrics,
+and Unicode table byte-for-byte with the committed artifacts. The package gate verifies that
+runtime dependencies are empty, inspects gem contents, installs into a clean
+temporary gem home, and smoke-tests the installed artifact.
+
+Performance thresholds are evaluated only between results captured on the same
+fixture, Ruby runtime, and machine. Capture before/after files with
+`benchmark/run.rb`, then run an explicit threshold gate:
+
+```sh
+ruby benchmark/run.rb --iterations=25 --warmup=5 --output=before.json
+# apply the candidate change, using the same host and Ruby
+ruby benchmark/run.rb --iterations=25 --warmup=5 --output=after.json
+bundle exec rake "benchmark:check[before.json,after.json,5,5]"
+```
+
+The final two arguments are the maximum allowed median-runtime and allocation
+regression percentages. The comparison requires identical fixture/result
+checksums, Ruby/OS/CPU/compiler/host metadata, warmup, batch, and iteration
+settings, YJIT state, and relevant environment knobs; incompatible or invalid
+results are rejected. GitHub-hosted CI uploads a report-only artifact because
+those runners do not provide a stable performance environment. Maintainers run
+the `Benchmark Gate` workflow at the immutable `benchmark-builder-v12` tag with
+a reviewed full candidate SHA. The base is fixed by
+`benchmark/baseline.commit`; callers cannot substitute it.
+`benchmark/trusted_builder.commit` pins the workflow revision that supplies the
+trusted harness, comparator, manifest, and fixtures on a one-job `ephemeral` +
+`json5-benchmark` self-hosted runner. It covers value, lexer, document, and error
+paths, uses predeclared balanced before/after process rounds, enforces both 5%
+thresholds on every round and their aggregate, and checks 1x/2x/4x linearity. Never attach
+the label to a persistent runner: candidate parser code is executed, so the
+runner must be isolated, one-time, and kept on a stable power/performance
+profile. The runner must be Linux, provide Bubblewrap at `/usr/bin/bwrap`, and
+provide Ruby from `/opt/hostedtoolcache`. Candidate code runs without network or
+inherited credentials in isolated user, mount, PID, IPC, UTS, cgroup, and
+network namespaces; its host inputs are read-only and only an ephemeral `/tmp`
+is writable.
+
+The workflow artifact is a tar archive containing aggregate `evidence.json`, a
+SHA-256 file manifest, and all raw measurements. A separate GitHub-hosted job
+revalidates it and creates a GitHub artifact attestation bound to the pinned
+builder workflow. The signed contents bind the exact candidate release commit.
+Before release, set `JSON5_BENCHMARK_EVIDENCE` to the downloaded `.tar.gz` file;
+the release task verifies that attestation before it accepts the fixed base,
+exact release/harness commit, complete manifest coverage, passing comparisons,
+and passing linearity evidence. This verification requires GitHub CLI network
+access.
+
+`release:check` also refuses uncommitted or untracked files, so commit intended
+generated evidence before running the final release gate.
+
+The generated parser, Automaton IR, verification report, metrics, grammar,
+source manifest, fixed Unicode 3.0.0 input, and conformance matrix are checked
+in. See `docs/conformance-matrix.md` for the coverage map and the
+design/work-plan documents under `.idea/` for the implementation boundary and
+release checklist.
+
+Security issues should be reported privately as described in [SECURITY.md](SECURITY.md).
+Conformance scope and known limitations are recorded in
+[docs/conformance-report.md](docs/conformance-report.md).
+
+## Compatibility
+
+The public API is `JSON5`; `Json5` remains an alias for the initial gem
+scaffold. The supported Ruby version is 3.2 or newer. This project does not
+execute input as Ruby code and never converts member names to symbols.
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/SECURITY.md

@@ -0,0 +1,9 @@
+# Security policy
+
+Please do not disclose security vulnerabilities in public issues or pull
+requests. Report them privately to the project maintainer through the contact
+address listed in the gem metadata, including a description, reproduction
+steps, affected versions, and any suggested mitigation.
+
+Please allow reasonable time for triage and coordinated disclosure. Do not
+include secrets or unrelated personal data in a report.

data/docs/conformance-matrix.md

@@ -0,0 +1,90 @@
+# JSON5 1.0.0 conformance matrix
+
+The matrix tracks the behavior required by the JSON5 1.0.0 specification and the
+ECMAScript 5.1 lexical rules used by it.
+
+Fixture IDs are stable evidence identifiers. Their source files, typed expected
+results, and provenance are recorded in `spec/fixtures/conformance/cases.yml`.
+
+| ID | Spec section | Requirement | Positive tests | Negative tests | Implementation | Status |
+|---|---|---|---|---|---|---|
+| TEXT-001 | JSON5Text | empty input is invalid because one value is required | - | `TEXT-EMPTY-001` | `grammar/json5.y` | covered |
+| TEXT-002 | JSON5Text | trailing whitespace and comments are accepted | `TEXT-TRIVIA-001` | - | `lib/json5/lexer.rb` | covered |
+| TEXT-003 | JSON5Text | a second top-level value is rejected | - | `TEXT-TRAILING-001` | `lib/json5/parser.rb` | covered |
+| TEXT-004 | JSON5Text | punctuation suffix tokens after a value are rejected | - | `TEXT-SUFFIX-001` | `lib/json5/parser.rb` | covered |
+| VALUE-001 | JSON5Value | object, array, string, number, Boolean, and null are top-level values | `TEXT-TOPLEVEL-001`<br>`VALUE-STRING-001`<br>`VALUE-BOOLEAN-001`<br>`VALUE-NULL-001`<br>`VALUE-TOPLEVEL-001` | - | `grammar/json5.y` | covered |
+| OBJ-001 | JSON5Object / JSON5Array | empty containers are accepted | `OBJ-EMPTY-001` | - | `grammar/json5.y` | covered |
+| OBJ-002 | JSON5Member / JSON5ElementList | one member or element is accepted | `OBJ-SINGLE-001` | - | `grammar/json5.y` | covered |
+| OBJ-003 | JSON5MemberList / JSON5ElementList | multiple members or elements are accepted | `OBJ-MULTIPLE-001` | - | `grammar/json5.y` | covered |
+| OBJ-004 | JSON5Object / JSON5Array | one trailing comma is accepted | `OBJECT-GRAMMAR-001`<br>`ARRAY-TRAILING-001` | - | `grammar/json5.y` | covered |
+| OBJ-005 | JSON5Object / JSON5Array | a second trailing comma is rejected | - | `OBJECT-DOUBLE-COMMA-001`<br>`ARR-DOUBLE-COMMA-001` | `grammar/json5.y` | covered |
+| ARR-001 | JSON5Array | array holes are rejected | - | `ARRAY-HOLE-001` | `grammar/json5.y` | covered |
+| OBJ-006 | JSON5MemberName | quoted and unquoted member names are accepted | `OBJ-NAMES-001` | - | `grammar/json5.y` | covered |
+| OBJ-007 | JSON5MemberName | literal keyword spellings are accepted as member names | `OBJECT-KEYWORDS-001` | - | `grammar/json5.y` | covered |
+| DUP-001 | API duplicate policy | last, first, error, and preserve policies are fixed | `OBJECT-DUPLICATE-001`<br>`DUP-POLICIES-001` | - | `lib/json5/ruby_value_builder.rb` | covered |
+| WS-001 | Whitespace | U+0009, U+000A, U+000B, U+000C, U+000D, and U+0020 are accepted | `WS-ASCII-001` | - | `lib/json5/lexer.rb` | covered |
+| WS-002 | Whitespace | U+00A0, U+2028, U+2029, and U+FEFF are accepted | `WS-UNICODE-001` | - | `lib/json5/lexer.rb` | covered |
+| WS-003 | Whitespace | every pinned Unicode 3.0 Zs character is accepted | `NUMBER-WHITESPACE-001`<br>`WS-ALL-ZS-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| COMMENT-001 | SingleLineComment | line comments terminate at LF, CRLF, CR, LS, PS, or EOF | `COMMENT-EOL-001` | - | `lib/json5/lexer.rb` | covered |
+| COMMENT-002 | MultiLineComment | a closed block comment is trivia | `COMMENT-SIMPLE-001` | - | `lib/json5/lexer.rb` | covered |
+| COMMENT-003 | MultiLineComment | nested-looking text closes at the first closing delimiter | `COMMENT-BLOCK-001` | - | `lib/json5/lexer.rb` | covered |
+| COMMENT-004 | MultiLineComment | an unclosed block comment is rejected | - | `COMMENT-UNCLOSED-001` | `lib/json5/lexer.rb` | covered |
+| COMMENT-005 | Comments | a slash that does not start a comment is rejected | - | `COMMENT-SLASH-001` | `lib/json5/lexer.rb` | covered |
+| COMMENT-006 | Lexical token boundaries | comments inside identifiers and numbers are rejected | - | `COMMENT-TOKEN-BOUNDARY-001` | `lib/json5/lexer.rb` | covered |
+| IDENT-001 | IdentifierStart | ASCII letters, dollar signs, and underscores are accepted | `IDENT-ASCII-001` | - | `lib/json5/lexer.rb` | covered |
+| IDENT-002 | IdentifierPart | decimal digits are accepted only after the start | `IDENT-DIGIT-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| IDENT-003 | IdentifierPart | combining marks are accepted only after the start | `IDENT-COMBINING-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| IDENT-004 | IdentifierPart | ZWNJ and ZWJ are accepted only after the start | `IDENT-ZWNJ-ZWJ-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| IDENT-005 | UnicodeEscapeSequence | four-digit Unicode escapes are accepted by position | `IDENT-UNICODE-ESCAPE-001` | - | `lib/json5/lexer.rb` | covered |
+| IDENT-006 | UnicodeEscapeSequence | invalid hex count and alternate escape forms are rejected | - | `IDENT-ESCAPE-LENGTH-001` | `lib/json5/lexer.rb` | covered |
+| IDENT-007 | IdentifierName | decoded escape code units are revalidated as start or part | - | `IDENT-ESCAPE-BOUNDARY-001` | `lib/json5/unicode_tables.rb` | covered |
+| IDENT-008 | IdentifierName / JSON5Value | escaped keywords are member names but not literal values | `IDENT-ESCAPED-KEYWORD-001` | `IDENT-ESCAPED-KEYWORD-002` | `lib/json5/lexer.rb` | covered |
+| IDENT-009 | IdentifierName / JSON5Value | truex and Infinityx are identifiers by maximal munch | - | `IDENT-KEYWORD-SUFFIX-001`<br>`IDENT-KEYWORD-SUFFIX-COMPLETE-001` | `lib/json5/lexer.rb` | covered |
+| IDENT-010 | JSON5MemberName | arbitrary strings are accepted as quoted keys | `IDENT-QUOTED-KEY-001` | - | `grammar/json5.y` | covered |
+| IDENT-011 | IdentifierName | pinned Unicode letters are accepted as member names | `IDENT-UNICODE-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| STRING-001 | StringLiteral | single- and double-quoted strings are accepted | `STRING-QUOTES-001`<br>`STRING-QUOTE-PAIR-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-002 | StringLiteral | mismatched delimiters are rejected | - | `STRING-MISMATCH-001` | `lib/json5/lexer.rb` | covered |
+| STRING-003 | EscapeSequence | every named escape decodes to its specified code unit | `STRING-NAMED-ESCAPES-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-004 | EscapeSequence | null escape is accepted and a following decimal digit is rejected | `STRING-ESCAPE-001` | `STRING-NULL-DIGIT-001` | `lib/json5/lexer.rb` | covered |
+| STRING-005 | HexEscapeSequence | exactly two hexadecimal digits are required | `STRING-HEX-ESCAPE-001` | `STRING-ESCAPE-MALFORMED-001` | `lib/json5/lexer.rb` | covered |
+| STRING-006 | UnicodeEscapeSequence | exactly four hexadecimal digits decode one UTF-16 code unit | `STRING-UNICODE-ESCAPE-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-007 | NonEscapeCharacter | non-special escape characters and escaped slash are accepted | `STRING-NONESCAPE-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-008 | EscapeSequence | decimal escapes one through nine are rejected | - | `STRING-DECIMAL-ESCAPE-001` | `lib/json5/lexer.rb` | covered |
+| STRING-009 | LineContinuation | LF, CR, CRLF, LS, and PS continuations are accepted | `STRING-CONTINUATION-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-010 | StringLiteral | unescaped LF and CR line terminators are rejected | - | `STRING-RAW-LINE-001` | `lib/json5/lexer.rb` | covered |
+| STRING-011 | StringLiteral / diagnostics | unescaped U+2028 and U+2029 are accepted with warnings | `STRING-LS-001`<br>`STRING-PS-001` | - | `lib/json5/diagnostic.rb` | covered |
+| STRING-012 | UTF-16 conversion | lone surrogates are preserved in code-unit mode and valid pairs combine | `STRING-LONE-SURROGATE-001`<br>`STRING-SURROGATE-PAIR-001` | `STRING-LONE-SURROGATE-002` | `lib/json5/ecma_string.rb` | covered |
+| STRING-013 | StringLiteral | unescaped NUL and non-line control characters are preserved | `STRING-CONTROL-001` | - | `lib/json5/lexer.rb` | covered |
+| STRING-014 | StringLiteral | unterminated quotes and terminal backslashes are rejected | - | `STRING-UNTERMINATED-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-001 | DecimalIntegerLiteral | zero and non-zero integers are accepted | `NUMBER-INTEGER-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-002 | DecimalIntegerLiteral | decimal integers with a leading zero are rejected | - | `NUMBER-LEADING-ZERO-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-003 | DecimalLiteral | 1.0, .1, 1., and 1.e2 shapes are accepted | `NUMBER-DECIMAL-001`<br>`NUMBER-DECIMAL-SHAPES-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-004 | ExponentPart | lower/upper E and absent/plus/minus exponent signs are accepted | `NUMBER-EXPONENT-CASE-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-005 | ExponentPart | an exponent without decimal digits is rejected | - | `NUMBER-EXPONENT-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-006 | HexIntegerLiteral | lower- and upper-case hexadecimal prefixes are accepted | `NUMBER-HEX-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-007 | HexIntegerLiteral | a hexadecimal prefix without valid digits is rejected | - | `NUMBER-MALFORMED-HEX-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-008 | NumericLiteral | explicit plus and minus are accepted on finite number forms | `NUMBER-FINITE-SIGNS-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-009 | NumericLiteral | Infinity and NaN accept absent, plus, and minus signs atomically | `NUMBER-INFINITY-001`<br>`NUMBER-NAN-001`<br>`NUMBER-SIGNED-001`<br>`NUMBER-SPECIAL-SIGNS-COMPLETE-001` | - | `lib/json5/lexer.rb` | covered |
+| NUMBER-010 | NumericLiteral | case-mismatched Infinity and NaN spellings are rejected | - | `NUMBER-SPECIAL-CASE-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-011 | NumericLiteral | invalid identifier suffixes cannot follow numeric or special values | - | `NUMBER-TOKEN-BOUNDARY-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-012 | NumericLiteral | whitespace or comments cannot separate a sign from its body | - | `NUMBER-COMMENT-SIGN-001`<br>`NUMBER-SIGN-TRIVIA-001` | `lib/json5/lexer.rb` | covered |
+| NUMBER-013 | Numeric conversion | minus-zero sign and binary64 bit pattern are preserved | `NUMBER-NEGATIVE-ZERO-001`<br>`NUMBER-FLOAT-BITS-001` | - | `lib/json5/number_value.rb` | covered |
+| NUMBER-014 | Numeric conversion / binary64 | rounding, overflow, and underflow follow fixed binary64 oracles | `NUMBER-HEX-ROUNDING-001`<br>`NUMBER-BINARY64-BOUNDARY-001` | - | `lib/json5/number_value.rb` | covered |
+| ENC-001 | Input encoding | invalid UTF-8 is rejected | - | `ENC-INVALID-001` | `lib/json5/input.rb` | covered |
+| UNICODE-001 | ECMAScript 5.1 IdentifierName | pinned Unicode 3.0.0 predicates match every BMP code point | `UNICODE-BMP-001` | - | `lib/json5/unicode_tables.rb` | covered |
+| LIMIT-001 | API limits | configured limits fail early | - | `LIMIT-BOUNDARY-001` | `lib/json5/limits.rb` | covered |
+| INPUT-001 | API load | load enforces limits even when a reader ignores chunk size | - | `INPUT-LIMIT-001` | `lib/json5/parser.rb` | covered |
+| API-001 | API option validation | load and Document reject invalid or unsupported options | - | `API-OPTIONS-001` | `lib/json5/parser.rb` | covered |
+| ERROR-001 | Error model | parser and builder errors expose source context | - | `ERROR-CONTEXT-001` | `lib/json5/errors.rb` | covered |
+| ERROR-002 | Error model | EOF diagnostics never extend beyond the source | - | `ERROR-EOF-001` | `lib/json5/lexer.rb` | covered |
+| PERF-001 | Resource safety | literal token context is released after reduction | - | `PERF-TOKEN-RETENTION-001` | `lib/json5/ruby_value_builder.rb` | covered |
+| DOC-001 | Document mode | lossless document spans and trivia | `DOC-LOSSLESS-001` | - | `lib/json5/document_parser.rb` | covered |
+| DIFF-001 | Strict JSON subset | values agree with the standard-library JSON parser | `JSON-DIFFERENTIAL-001` | - | `lib/json5/parser.rb` | covered |
+
+## Fuzz regressions
+
+The deterministic generator configuration and invalid-mutation registry live in
+`spec/fixtures/conformance/fuzz.yml`. When a seed finds a failure, follow the
+minimization and stable-fixture procedure in `spec/fixtures/conformance/README.md`;
+the generated source is never accepted or rejected solely because another JSON5
+implementation behaves the same way.

data/docs/conformance-report.md

@@ -0,0 +1,29 @@
+# JSON5 conformance report
+
+Generated from `docs/conformance-matrix.md`.
+
+- JSON5 specification: 1.0.0 (`36f9418ed339580e362eb370fd084a235e361b8e`)
+- ECMAScript lexical baseline: 5.1 / Unicode 3.0.0
+- Ibex: 0.3.0, embedded Pure Ruby parser
+- Supported Ruby CI matrix: 3.2, 3.3, 3.4, 4.0
+- Matrix rows: 72
+- Covered: 72
+- Planned: 0
+- Blocked: 0
+- Generated automaton conflicts: 0
+- Strict Automaton IR verification: valid
+- Specification-derived fixtures: 33 (22 positive, 11 negative, 2 diagnostic-bearing)
+- Linked executable evidence examples: 62
+- Deterministic fuzz seeds: 12648430, 1592594996, 3735928559
+- Deterministic fuzz iterations: 80 per seed (240 total)
+- Deterministic fuzz corpus SHA-256: `52102866735c93ce7a3efbec11b512862c071ea43e2a30728903e4f8e3f0f156`
+- Single-edit invalid mutations: 9
+- Source provenance: `tool/sources.yml`; pinned Unicode SHA-256 verified
+- Official JSON5 corpus: not vendored; coverage is specification-derived
+- External differential: not used as the conformance oracle
+- Known limitations: none within the documented strict JSON5 1.0.0 scope
+- Performance baseline: `benchmark/results/baseline.json`
+
+The report is evidence for the repository's current test suite. Performance
+results remain machine-specific. The matrix does not by itself constitute a
+claim that every third-party corpus or extension is supported.

data/grammar/json5.y

@@ -0,0 +1,74 @@
+class JSON5::GeneratedParser
+token STRING NUMBER IDENTIFIER_NAME TRUE FALSE NULL INFINITY NAN
+start json5_text
+expect 0
+options no_result_var
+rule
+  json5_text
+    : value { result = val[0] }
+
+  value
+    : object { result = val[0] }
+    | array { result = val[0] }
+    | STRING { result = @builder.string(val[0]) }
+    | NUMBER { result = @builder.number(val[0]) }
+    | TRUE { result = @builder.literal(val[0], true) }
+    | FALSE { result = @builder.literal(val[0], false) }
+    | NULL { result = @builder.literal(val[0], nil) }
+    | INFINITY { result = @builder.number(val[0]) }
+    | NAN { result = @builder.number(val[0]) }
+
+  object
+    : '{' '}' { result = @builder.object([], val[0], val[1]) }
+    | '{' members '}' { result = @builder.object(val[1], val[0], val[2]) }
+    | '{' members ',' '}' { result = @builder.object(val[1], val[0], val[3], val[2]) }
+
+  members
+    : member { result = @builder.member_list(val[0]) }
+    | members ',' member { result = @builder.append_member(val[0], val[2], val[1]) }
+
+  member
+    : member_name ':' value { result = @builder.member(val[0], val[1], val[2]) }
+
+  member_name
+    : STRING { result = @builder.member_name(val[0]) }
+    | IDENTIFIER_NAME { result = @builder.member_name(val[0]) }
+    | TRUE { result = @builder.member_name(val[0]) }
+    | FALSE { result = @builder.member_name(val[0]) }
+    | NULL { result = @builder.member_name(val[0]) }
+    | INFINITY { result = @builder.member_name(val[0]) }
+    | NAN { result = @builder.member_name(val[0]) }
+
+  array
+    : '[' ']' { result = @builder.array([], val[0], val[1]) }
+    | '[' elements ']' { result = @builder.array(val[1], val[0], val[2]) }
+    | '[' elements ',' ']' { result = @builder.array(val[1], val[0], val[3], val[2]) }
+
+  elements
+    : value { result = @builder.element_list(val[0]) }
+    | elements ',' value { result = @builder.append_element(val[0], val[2], val[1]) }
+end
+---- inner
+def initialize(lexer, builder)
+  @lexer = lexer
+  @builder = builder
+  super()
+end
+
+def parse_tokens
+  do_parse
+end
+
+def next_token
+  token = @lexer.next_token
+  @builder.observe_token(token)
+  return false if token.kind == :EOF
+
+  payload = if token.kind.is_a?(String)
+              @builder.retain_punctuation_tokens? ? token : nil
+            else
+              token.value
+            end
+  [token.kind, payload]
+end
+---- footer

data/lib/json5/ascii_classification.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSON5
+  module ASCIIClassification
+    WHITESPACE = 1 << 0
+    DIGIT = 1 << 1
+    HEX_DIGIT = 1 << 2
+    IDENTIFIER_START = 1 << 3
+    IDENTIFIER_PART = 1 << 4
+    QUOTE = 1 << 5
+    PUNCTUATOR = 1 << 6
+    SLASH = 1 << 7
+    BACKSLASH = 1 << 8
+    LINE_TERMINATOR = 1 << 9
+
+    TABLE = Array.new(256, 0).tap do |table|
+      [0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20].each { |byte| table[byte] |= WHITESPACE }
+      (0x30..0x39).each { |byte| table[byte] |= DIGIT | HEX_DIGIT | IDENTIFIER_PART }
+      (0x41..0x46).each { |byte| table[byte] |= HEX_DIGIT }
+      (0x61..0x66).each { |byte| table[byte] |= HEX_DIGIT }
+      (0x41..0x5a).each { |byte| table[byte] |= IDENTIFIER_START | IDENTIFIER_PART }
+      (0x61..0x7a).each { |byte| table[byte] |= IDENTIFIER_START | IDENTIFIER_PART }
+      [0x24, 0x5f].each { |byte| table[byte] |= IDENTIFIER_START | IDENTIFIER_PART }
+      [0x22, 0x27].each { |byte| table[byte] |= QUOTE }
+      [0x7b, 0x7d, 0x5b, 0x5d, 0x3a, 0x2c].each { |byte| table[byte] |= PUNCTUATOR }
+      table[0x2f] |= SLASH
+      table[0x5c] |= BACKSLASH
+      [0x0a, 0x0d].each { |byte| table[byte] |= LINE_TERMINATOR }
+    end.freeze
+  end
+end

data/lib/json5/diagnostic.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module JSON5
+  class Diagnostic
+    attr_reader :severity, :code, :message, :filename, :byte_offset,
+      :end_byte_offset, :line, :column
+
+    def initialize(code:, message:, severity: :warning, filename: nil,
+                   byte_offset: nil, end_byte_offset: nil, line: nil,
+                   column: nil)
+      @severity = severity.to_sym
+      @code = code.to_s.dup.freeze
+      @message = message.to_s.dup.freeze
+      @filename = filename.nil? ? nil : filename.to_s.dup.freeze
+      @byte_offset = byte_offset
+      @end_byte_offset = end_byte_offset
+      @line = line
+      @column = column
+      freeze
+    end
+
+    def to_h
+      {
+        severity: severity,
+        code: code,
+        message: message,
+        filename: filename,
+        byte_offset: byte_offset,
+        end_byte_offset: end_byte_offset,
+        line: line,
+        column: column
+      }
+    end
+  end
+
+  class DiagnosticSink
+    def self.build(target, filename: nil)
+      new(target, filename: filename)
+    end
+
+    def self.write_default_warning(diagnostic)
+      Warning.warn("#{diagnostic.message} (#{diagnostic.code})\n")
+    end
+
+    def initialize(target, filename: nil)
+      @target = target
+      @filename = filename
+    end
+
+    def emit(code:, message:, byte_offset:, end_byte_offset:, line: nil, column: nil)
+      diagnostic = Diagnostic.new(
+        code: code,
+        message: message,
+        filename: @filename,
+        byte_offset: byte_offset,
+        end_byte_offset: end_byte_offset,
+        line: line,
+        column: column
+      )
+      if @target.is_a?(Array)
+        @target << diagnostic
+      elsif @target.respond_to?(:call)
+        @target.call(diagnostic)
+      elsif @target != :ignore
+        self.class.write_default_warning(diagnostic)
+      end
+      diagnostic
+    end
+  end
+end

data/lib/json5/document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSON5
+  class Document
+    attr_reader :source, :root, :diagnostics, :trailing_trivia, :line_map
+
+    def initialize(source:, root:, diagnostics:, trailing_trivia: [])
+      @source = source
+      @root = root
+      @diagnostics = diagnostics.dup.freeze
+      @trailing_trivia = trailing_trivia.dup.freeze
+      @line_map = LineMap.new(source)
+      freeze
+    end
+
+    def raw
+      source
+    end
+  end
+end

data/lib/json5/document_nodes.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module JSON5
+  ByteSpan = Data.define(:start_byte, :end_byte)
+
+  class Node
+    attr_reader :type, :source, :raw_span, :start_byte, :end_byte, :leading_trivia, :trailing_trivia
+
+    def initialize(type:, source:, start_byte:, end_byte:, leading_trivia: [], trailing_trivia: [])
+      @type = type.to_sym
+      @source = source
+      @start_byte = start_byte
+      @end_byte = end_byte
+      @raw_span = ByteSpan.new(start_byte, end_byte)
+      @leading_trivia = leading_trivia.dup.freeze
+      @trailing_trivia = trailing_trivia.dup.freeze
+      freeze
+    end
+
+    def raw
+      source.byteslice(start_byte...end_byte)
+    end
+  end
+
+  class StringNode < Node
+    attr_reader :code_units, :quote, :escape_spans
+
+    def initialize(code_units:, quote:, escape_spans: [], **attributes)
+      @code_units = code_units
+      @quote = quote
+      @escape_spans = escape_spans.dup.freeze
+      super(type: :string, **attributes)
+    end
+  end
+
+  class NumberNode < Node
+    attr_reader :classification, :sign
+
+    def initialize(classification:, sign:, **attributes)
+      @classification = classification
+      @sign = sign
+      super(type: :number, **attributes)
+    end
+
+    alias lexeme raw
+  end
+
+  class IdentifierNameNode < Node
+    attr_reader :code_units, :decoded_code_units
+
+    def initialize(code_units:, **attributes)
+      @code_units = code_units
+      @decoded_code_units = code_units
+      super(type: :identifier_name, **attributes)
+    end
+  end
+
+  class LiteralNode < Node
+    attr_reader :value
+
+    def initialize(value:, **attributes)
+      @value = value
+      super(type: :literal, **attributes)
+    end
+  end
+
+  class MemberNode < Node
+    attr_reader :name, :value, :colon_span, :colon_start_byte, :colon_end_byte, :colon_leading_trivia
+
+    def initialize(name:, value:, colon_start_byte:, colon_end_byte:, colon_leading_trivia: [], **attributes)
+      @name = name
+      @value = value
+      @colon_start_byte = colon_start_byte
+      @colon_end_byte = colon_end_byte
+      @colon_span = ByteSpan.new(colon_start_byte, colon_end_byte)
+      @colon_leading_trivia = colon_leading_trivia.dup.freeze
+      super(type: :member, **attributes)
+    end
+  end
+
+  class ObjectNode < Node
+    attr_reader :members
+
+    def initialize(members:, **attributes)
+      @members = members.dup.freeze
+      super(type: :object, **attributes)
+    end
+  end
+
+  class ArrayNode < Node
+    attr_reader :elements, :element_trailing_trivia
+
+    def initialize(elements:, element_trailing_trivia: [], **attributes)
+      @elements = elements.dup.freeze
+      @element_trailing_trivia = element_trailing_trivia.map { |trivia| trivia.dup.freeze }.freeze
+      super(type: :array, **attributes)
+    end
+  end
+end