lutaml-openapi 0.1.1 → 0.1.2

data/lib/lutaml/openapi/corpus_audit.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "lutaml/openapi"
+
+module Lutaml
+  module Openapi
+    # The metanorma-ogc#153 corpus audit as a repeatable task: parse
+    # every vendored corpus fixture, assert the lossless round-trip,
+    # report the description/summary coverage matrix.
+    module CorpusAudit
+      FIXTURES = File.expand_path("../../../spec/fixtures",
+                                  __dir__)
+
+      def self.files
+        Dir.glob("#{FIXTURES}/*.{yaml,yml,json}")
+      end
+
+      def self.matrix
+        files.map { |path| row(path) }
+      end
+
+      def self.row(path)
+        doc = Lutaml::Openapi.parse(File.read(path))
+        raw = doc.to_hash
+        schema_stats = schema_stats(raw)
+        { file: File.basename(path), openapi: raw["openapi"],
+          lossless: lossless?(path, doc), **schema_stats }
+      end
+
+      def self.schema_stats(raw)
+        schemas = raw.dig("components", "schemas") || {}
+        documented = schemas.values.count do |s|
+          s.is_a?(Hash) && s["description"].is_a?(String) &&
+            !s["description"].strip.empty?
+        end
+        { schemas: schemas.size, schemas_documented: documented,
+          **operation_stats(raw) }
+      end
+
+      def self.operation_stats(raw)
+        operations = 0
+        with_text = 0
+        each_operation(raw) do |op|
+          operations += 1
+          text = op["summary"] || op["description"]
+          with_text += 1 if text.is_a?(String) && !text.strip.empty?
+        end
+        { operations: operations, operations_with_text: with_text }
+      end
+
+      def self.each_operation(raw, &block)
+        paths = raw["paths"] || {}
+        paths.each_value do |item|
+          next unless item.is_a?(Hash)
+
+          yield_operations(item, &block)
+        end
+      end
+
+      def self.yield_operations(item, &)
+        item.each_value do |operation_entry|
+          next unless operation?(operation_entry)
+
+          yield operation_entry
+        end
+      end
+
+      def self.operation?(operation_entry)
+        operation_entry.is_a?(Hash) && operation_entry["responses"]
+      end
+
+      def self.lossless?(path, doc)
+        raw = Lutaml::Openapi.parse_raw(File.read(path))
+        # The model is JSON-keyed: YAML integer keys (unquoted response
+        # codes) stringify through the pipeline, so compare against the
+        # JSON-normalized raw. to_hash is the serialization contract:
+        # 3.0 sources denormalize back on it. Hash == is deep and
+        # key-order-insensitive.
+        normalized = JSON.parse(JSON.generate(raw))
+        doc.to_hash == normalized
+      end
+    end
+  end
+end

data/lib/lutaml/openapi/spa.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Openapi
+    # Generates a single-file SPA documentation site for an OpenAPI
+    # document. The frontend bundle (frontend/dist) is built by the
+    # frontend toolchain and is expected to exist at generation time —
+    # it enters the gem only immediately before a release.
+    module Spa
+      DIST = File.expand_path("../../../frontend/dist", __dir__)
+
+      module_function
+
+      def generate(document, title: nil)
+        app_js = File.read(File.join(DIST, "app.iife.js"))
+        style = File.join(DIST, "style.css")
+        data = safe_json(document.to_hash)
+
+        title ||= document.to_hash.dig("info", "title") || "OpenAPI document"
+
+        build_html(escape(title), data, app_js, style_content(style))
+      end
+
+      # JSON embedded in a <script> element: escape "<" so payload
+      # strings containing "</script>" (or any markup) cannot break out
+      def safe_json(obj)
+        JSON.generate(obj).gsub("<", "\\u003c")
+      end
+
+      def build_html(title, data, app_script, css)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>#{title}</title>
+            <style>#{css}</style>
+          </head>
+          <body>
+            <div id="app"></div>
+            <script>window.OPENAPI_DATA = #{data};</script>
+            <script>#{app_script}</script>
+          </body>
+          </html>
+        HTML
+      end
+
+      def style_content(path)
+        File.exist?(path) ? File.read(path) : ""
+      end
+
+      def escape(text)
+        text.to_s.gsub("&", "&amp;").gsub("<", "&lt;")
+      end
+    end
+  end
+end

data/lib/lutaml/openapi/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Openapi
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/lib/lutaml/openapi.rb

@@ -15,6 +15,8 @@ module Lutaml
   # Anything unmodeled rides the extensions catch-all — documents
   # round-trip verbatim.
   module Openapi
+    autoload :CorpusAudit, "lutaml/openapi/corpus_audit"
+    autoload :Spa, "lutaml/openapi/spa"
     autoload :VERSION, "lutaml/openapi/version"
     autoload :Document, "lutaml/openapi/document"
     autoload :Oas30, "lutaml/openapi/oas30"

data/rakelib/corpus.rake

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "lutaml/openapi/corpus_audit"
+
+namespace :corpus do
+  desc "Audit the vendored OGC corpus: lossless round-trip + coverage matrix"
+  task :audit do
+    rows = Lutaml::Openapi::CorpusAudit.matrix
+    format = "%-46s %-7s lossless=%-5s schemas=%-4d " \
+             "documented=%-4d ops=%-3d ops_text=%d"
+    rows.each do |r|
+      puts format(format, r[:file], r[:openapi], r[:lossless], r[:schemas],
+                  r[:schemas_documented], r[:operations],
+                  r[:operations_with_text])
+    end
+    failures = rows.reject { |r| r[:lossless] }
+    unless failures.empty?
+      abort "corpus:audit: lossless round-trip failed for " \
+            "#{failures.map { |r| r[:file] }.join(', ')}"
+    end
+  end
+end
+
+namespace :frontend do
+  File.expand_path("frontend/dist", __dir__)
+  node_modules = File.expand_path("frontend/node_modules", __dir__)
+
+  task :install do
+    unless File.directory?(node_modules)
+      Dir.chdir("frontend") do
+        sh "npm install"
+      end
+    end
+  end
+
+  task build: :install do
+    Dir.chdir("frontend") { sh "npm run build" }
+  end
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-openapi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -80,10 +81,26 @@ files:
 - PLAN.md
 - README.md
 - Rakefile
+- frontend/dist/app.iife.js
+- frontend/dist/style.css
+- frontend/index.html
+- frontend/package-lock.json
+- frontend/package.json
+- frontend/src/App.vue
+- frontend/src/app.ts
+- frontend/src/components/OverviewView.vue
+- frontend/src/components/PathsView.vue
+- frontend/src/components/SchemasView.vue
+- frontend/src/style.css
+- frontend/tsconfig.json
+- frontend/vite.config.ts
 - lib/lutaml/openapi.rb
+- lib/lutaml/openapi/corpus_audit.rb
 - lib/lutaml/openapi/document.rb
 - lib/lutaml/openapi/oas30.rb
+- lib/lutaml/openapi/spa.rb
 - lib/lutaml/openapi/version.rb
+- rakelib/corpus.rake
 homepage: https://github.com/lutaml/lutaml-openapi
 licenses:
 - BSD-2-Clause
@@ -91,6 +108,7 @@ metadata:
   homepage_uri: https://github.com/lutaml/lutaml-openapi
   source_code_uri: https://github.com/lutaml/lutaml-openapi
   changelog_uri: https://github.com/lutaml/lutaml-openapi/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -105,7 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: OpenAPI 3.0/3.1 as a lossless lutaml-model
 test_files: []