lutaml-jsonschema 0.1.23 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6542de697d4e9bb258f8b2291430b9cc8c2244ec3b46ac7e30e92b7192e5d19
-  data.tar.gz: bc5641c42ecc85dad8098eb35302ff26ff2912f9f1a207f70301a4960a2e3883
+  metadata.gz: 5def50283e10b93eae1ca02c54374c259f64f8b530b9edde9baddc7aa6e17fee
+  data.tar.gz: 5a6367729b6f4543bcc3d09246bdf663918e2bd977cb2591065563887e8c0fec
 SHA512:
-  metadata.gz: fc41187d4a77c7a6c1c613696f1687595968928478bc4e6ee0fdcdb0a1fcca21816655efc36ca2989ddd6ed72bae238bc5e16dc949a3237138e234050b038433
-  data.tar.gz: bea291d15415a80a8487c44143065aec658e3a00c6235703de99bba8907e43f1377e2f4bf23fd4acfffdef8abadc25eecf748884da6175a183c7191b2bfc704e
+  metadata.gz: fa6880c0ef08bdaa4277f1ca2d71f9943fc7a6facfe6071669d0141ed038949b7cf652f32e1b668e7469d3dac2ac57671696114a2d31e42a12549392132230c7
+  data.tar.gz: ab108839554ad9cdd16ec05eb61756fba5e01a51d6ac0b9f1b541d5ad6939de2ec40696e44a39aaf2ceeeed2044659dfee0d5ce8224100509ab960d87489e83c

data/.rubocop_todo.yml

@@ -187,7 +187,7 @@ Metrics/AbcSize:
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
-  Max: 54
+  Max: 57
 
 # Offense count: 12
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.

data/CLAUDE.md

@@ -21,7 +21,10 @@ bundle exec rake                           # spec + rubocop (what CI runs)
 bundle exec rake frontend:build            # npm install + vite build → frontend/dist
 cd frontend && npm test                    # vitest (frontend unit tests)
 
-bundle exec exe/lutaml-jsonschema spa|combine|validate SCHEMA_FILES...
+bundle exec exe/lutaml-jsonschema spa SCHEMA_FILES... [--diff BASELINE...]
+bundle exec exe/lutaml-jsonschema combine|validate SCHEMA_FILES...
+bundle exec exe/lutaml-jsonschema export SCHEMA_FILES... -f cddl|openapi|xsd|adoc
+bundle exec exe/lutaml-jsonschema diff OLD NEW [--format json]
 ```
 
 `frontend/dist/` and `Gemfile.lock` are gitignored. `frontend/dist/` must exist (run `rake frontend:build`) for the `spa` command and for packaging — the gemspec ships it via `Dir.glob("frontend/dist/*")`.
@@ -34,10 +37,11 @@ Data flow: schema files → `SchemaSet.load_from_files` → `Spa::SpaBuilder`
 - **`Schema`** — the central model of a JSON Schema document. Every `$`-prefixed keyword is a `dollar_`-prefixed attribute (`$schema` → `dollar_schema`) via json mappings. `Schema.from_json` / `to_json` are lutaml-model serialization.
 - **`SchemaSet`** — in-memory named collection of schemas plus `$ref` resolution (local `#/...` pointers and relative `./file.json` refs through `ReferenceResolver`) and validation.
 - **`SchemaStore`** — `SchemaSet` subclass that adds on-disk persistence through **lutaml-store** (`PackageStore`, package shape from `LjrPackageDefinition`).
-- **`Combiner`** — merges a `SchemaSet` into one document: hoists all definitions, adds a top-level `$ref` property per source schema, rewrites `#/definitions/` → `#/$defs/`.
+- **`Combiner`** — compatibility facade; bundling lives in `SchemaSet#bundle` (hoists definitions, adds a top-level `$ref` property per source schema, rewrites `#/definitions/` → `#/$defs/`).
 - **`Spa::*`** — `SpaBuilder` flattens a `SchemaSet` into a `SpaDocument` (metadata, `SpaSchema` list, flat `search_index` for FlexSearch). `Spa::Generator` renders through an `OutputStrategy`; `VueInlinedStrategy` is the only implementation.
 - **`Configuration`** — YAML config for the SPA (title, theme, appearance…), loaded by `Cli#spa -c`.
-- **`Cli`** — Thor commands: `spa` (generate docs), `combine` (merge schemas), `validate` (parse + shallow structural checks).
+- **`Cli`** — Thor commands: `spa` (generate docs; `--diff` embeds a classified change set), `combine` (merge schemas), `export` (cddl/openapi/xsd/adoc), `diff` (exits 1 on breaking changes), `validate` (meta-schema checks), `version`.
+- **`TupleItem`** — schema-or-boolean wrapper used by `items`/`prefixItems` arrays and composition collections; models that accept `true`/`false` store booleans in companion `*_boolean` attributes and expose `*_value` helpers.
 
 ## JSON engine: yeptris
 

data/Rakefile

@@ -9,7 +9,17 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task default: %i[spec rubocop perf frontend:audit]
+
+namespace :perf do
+  desc "Pipeline performance harness with regression caps (TODO.sota/08)"
+  task :profile do
+    ruby "benchmark/pipeline_profile.rb"
+  end
+end
+
+desc "Run the pipeline performance regression gate"
+task perf: "perf:profile"
 
 namespace :frontend do
   desc "Build the Vue frontend"
@@ -19,6 +29,11 @@ namespace :frontend do
       sh "npm run build"
     end
   end
+
+  desc "axe-core accessibility audit of the generated SPA (needs Chrome)"
+  task :audit do
+    ruby "script/axe_audit"
+  end
 end
 
 task :build_frontend do

data/benchmark/pipeline_profile.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Pipeline performance harness (TODO.sota/08).
+#
+# Measures the two budgeted paths on the real-world heroku.json fixture:
+#   - Schema.from_json (model construction)
+#   - end-to-end SPA generation (SchemaSet + SpaBuilder + inlined HTML)
+#
+# Metrics are reported both absolutely and as a ratio to a stdlib
+# JSON.parse of the same document. The ratio is the machine-independent
+# signal: CI runners vary wildly in absolute speed, but the C parser is
+# a stable per-machine yardstick. Regression caps apply to the ratio.
+#
+# Usage: bundle exec ruby benchmark/pipeline_profile.rb [runs]
+
+require "benchmark"
+require "json"
+require "lutaml/jsonschema"
+require "tmpdir"
+
+FIXTURES = Dir[File.expand_path("../spec/fixtures/*.json", __dir__)]
+HEROKU = File.expand_path("../spec/fixtures/heroku.json", __dir__)
+DATA = File.read(HEROKU)
+RUNS = (ARGV[0] || 3).to_i
+
+# Regression caps, calibrated per environment: the ratio looked
+# machine-independent but is not — CI runners (2 vCPU, shared) inflate the
+# Ruby-vs-C balance ~2x versus a local M-series machine (first real CI run:
+# from_json 5901x, e2e 7853x, suite itself green). Caps catch real
+# regressions (1.3x+ of the environment's own baseline) without flaking.
+# Aspirational budgets are printed separately.
+IN_CI = ["true", "1"].include?(ENV.fetch("CI", nil))
+CAP_FROM_JSON_RATIO, CAP_E2E_RATIO =
+  if IN_CI
+    [7_500, 10_000]
+  else
+    [2_600, 5_000]
+  end
+
+def median(values)
+  values.sort[values.length / 2]
+end
+
+def measure(runs, &)
+  Array.new(runs) { Benchmark.realtime(&) }
+end
+
+Schema = Lutaml::Jsonschema::Schema
+
+# Warmup
+Schema.from_json(DATA)
+JSON.parse(DATA)
+
+parse_times = measure(RUNS) { JSON.parse(DATA) }
+from_json_times = measure(RUNS) { Schema.from_json(DATA) }
+
+tmp = Dir.mktmpdir
+frontend_built = File.exist?(
+  File.join(Lutaml::Jsonschema::Spa::VueInlinedStrategy::FRONTEND_DIST,
+            "app.iife.js"),
+)
+generate = lambda do
+  set = Lutaml::Jsonschema::SchemaSet.load_from_files(*FIXTURES)
+  Lutaml::Jsonschema::Spa::Generator.new(set, tmp).generate
+end
+if frontend_built
+  generate.call
+  e2e_times = measure(RUNS) { generate.call }
+else
+  e2e_times = nil
+end
+
+parse_ms = median(parse_times) * 1000
+from_json_ms = median(from_json_times) * 1000
+e2e_ms = e2e_times && (median(e2e_times) * 1000)
+
+from_json_ratio = from_json_ms / parse_ms
+e2e_ratio = e2e_ms && (e2e_ms / parse_ms)
+
+per_100kb = from_json_ms / (DATA.bytesize / 100_000.0)
+html_bytes = if e2e_ms
+               File.size(File.join(tmp, "index.html"))
+             end
+
+puts "heroku.json: #{DATA.bytesize} bytes, #{FIXTURES.length} fixtures, " \
+     "runs=#{RUNS}"
+puts format("JSON.parse (reference):   %<ms>10.3f ms", ms: parse_ms)
+puts format("Schema.from_json:         %<ms>10.3f ms  " \
+            "(%<per>0f ms/100KB, %<ref>0fx ref)",
+            ms: from_json_ms, per: per_100kb, ref: from_json_ratio)
+if e2e_ms
+  puts format("e2e spa generate:         %<ms>10.3f ms  (%<ref>0fx ref)",
+              ms: e2e_ms, ref: e2e_ratio)
+  puts format("index.html:               %<bytes>10d bytes " \
+              "(%<ratio>0.2fx input)",
+              bytes: html_bytes, ratio: html_bytes.to_f / DATA.bytesize)
+else
+  puts "e2e spa generate:         skipped (frontend/dist not built)"
+end
+puts
+puts "environment: #{IN_CI ? 'CI' : 'local'}"
+puts "budgets (aspirational): from_json <= #{DATA.bytesize / 1000} ms " \
+     "(100 ms/100KB), e2e <= 1 s/MB"
+puts "regression caps:        from_json ratio <= #{CAP_FROM_JSON_RATIO}, " \
+     "e2e ratio <= #{CAP_E2E_RATIO}"
+
+failures = []
+failures << "from_json ratio #{from_json_ratio.round} > #{CAP_FROM_JSON_RATIO}" \
+  if from_json_ratio > CAP_FROM_JSON_RATIO
+failures << "e2e ratio #{e2e_ratio.round} > #{CAP_E2E_RATIO}" \
+  if e2e_ratio && e2e_ratio > CAP_E2E_RATIO
+
+if failures.empty?
+  puts "PERF OK"
+else
+  warn "PERF REGRESSION: #{failures.join('; ')}"
+  exit 1
+end