lutaml-jsonschema 0.1.0

data/lib/lutaml/jsonschema/spa/spa_builder.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaBuilder
+        def initialize(schema_set, metadata: nil)
+          @schema_set = schema_set
+          @metadata = metadata || Metadata.new
+        end
+
+        def build
+          infer_metadata_title if @metadata.title.nil?
+
+          schemas = build_schemas
+          search_index = build_search_index(schemas)
+
+          SpaDocument.new(
+            metadata: @metadata,
+            schemas: schemas,
+            search_index: search_index
+          )
+        end
+
+        private
+
+        def infer_metadata_title
+          first_schema = @schema_set.schemas.values.first
+          @metadata.title = first_schema&.title if first_schema&.title
+        end
+
+        def build_schemas
+          @schema_set.schemas.map do |name, schema|
+            build_spa_schema(name, schema)
+          end
+        end
+
+        def build_spa_schema(name, schema)
+          all_props = collect_all_properties(schema)
+          all_defs = collect_all_definitions(schema)
+          all_required = collect_all_required(schema)
+
+          properties = build_properties(all_props, schema, all_required)
+          definitions = build_definitions_from_entries(all_defs, schema)
+
+          SpaSchema.new(
+            name: name,
+            title: schema.title,
+            description: schema.description,
+            type: schema.type,
+            properties: properties,
+            definitions: definitions,
+            required: all_required,
+            examples: schema.examples
+          )
+        end
+
+        def collect_all_properties(schema)
+          entries = schema.property_entries.dup
+          composition_schemas(schema).each do |s|
+            entries.concat(collect_all_properties(s))
+          end
+          entries
+        end
+
+        def collect_all_definitions(schema)
+          entries = schema.definition_entries.dup
+          composition_schemas(schema).each do |s|
+            entries.concat(collect_all_definitions(s))
+          end
+          entries
+        end
+
+        def collect_all_required(schema)
+          required = schema.required.dup
+          composition_schemas(schema).each do |s|
+            required.concat(collect_all_required(s))
+          end
+          required
+        end
+
+        def composition_schemas(schema)
+          schema.all_of + schema.any_of + schema.one_of
+        end
+
+        def build_definitions_from_entries(entries, root_schema)
+          entries.map do |entry|
+            s = entry.schema
+            properties = build_properties(s.property_entries, root_schema, s.required)
+
+            SpaDefinition.new(
+              name: entry.name,
+              title: s.title,
+              description: s.description,
+              type: s.type,
+              properties: properties,
+              required: s.required,
+              examples: s.examples
+            )
+          end
+        end
+
+        def build_properties(entries, root_schema, all_required = root_schema.required)
+          entries.map do |entry|
+            resolved = resolve_property(entry, root_schema)
+            SpaProperty.new(
+              name: entry.name,
+              title: resolved.title,
+              description: resolved.description,
+              type: resolved.type,
+              format: resolved.format,
+              required: all_required.include?(entry.name),
+              default: resolved.default,
+              pattern: resolved.pattern,
+              enum: resolved.enum,
+              ref: entry.schema.dollar_ref,
+              min_length: resolved.min_length,
+              max_length: resolved.max_length,
+              minimum: resolved.minimum,
+              maximum: resolved.maximum,
+              items_type: resolved.items&.type,
+              deprecated: resolved.deprecated,
+              examples: resolved.examples
+            )
+          end
+        end
+
+        def resolve_property(entry, root_schema)
+          return entry.schema unless entry.schema.dollar_ref
+
+          @schema_set.resolve_ref(entry.schema.dollar_ref, root_schema) || entry.schema
+        end
+
+        def build_search_index(schemas)
+          schemas.flat_map do |spa_schema|
+            raw_schema = @schema_set.schemas[spa_schema.name]
+
+            entries = [SpaSearchEntry.new(
+              name: spa_schema.name,
+              title: spa_schema.title,
+              type: "schema",
+              schema_name: spa_schema.name
+            )]
+
+            spa_schema.properties.each do |prop|
+              entries << SpaSearchEntry.new(
+                name: prop.name,
+                title: prop.title,
+                type: "property",
+                schema_name: spa_schema.name
+              )
+            end
+
+            spa_schema.definitions.each do |defn|
+              entries << SpaSearchEntry.new(
+                name: defn.name,
+                title: defn.title,
+                type: "definition",
+                schema_name: spa_schema.name
+              )
+
+              defn.properties.each do |prop|
+                entries << SpaSearchEntry.new(
+                  name: prop.name,
+                  title: prop.title,
+                  type: "property",
+                  schema_name: spa_schema.name
+                )
+              end
+            end
+
+            entries
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/spa_definition.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaDefinition < Base
+        attribute :name, :string
+        attribute :title, :string
+        attribute :description, :string
+        attribute :type, :string
+        attribute :properties, SpaProperty, collection: true, initialize_empty: true
+        attribute :required, :string, collection: true
+        attribute :examples, :string, collection: true
+
+        json do
+          map "name", to: :name
+          map "title", to: :title
+          map "description", to: :description
+          map "type", to: :type
+          map "properties", to: :properties
+          map "required", to: :required
+          map "examples", to: :examples
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/spa_document.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaDocument < Base
+        attribute :metadata, Metadata
+        attribute :schemas, SpaSchema, collection: true, initialize_empty: true
+        attribute :search_index, SpaSearchEntry, collection: true, initialize_empty: true
+
+        json do
+          map "metadata", to: :metadata, render_nil: true, render_default: true, render_empty: true
+          map "schemas", to: :schemas
+          map "searchIndex", to: :search_index
+        end
+
+        def self.from_schema_set(schema_set, metadata: nil)
+          SpaBuilder.new(schema_set, metadata: metadata).build
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/spa_property.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaProperty < Base
+        attribute :name, :string
+        attribute :title, :string
+        attribute :description, :string
+        attribute :type, :string
+        attribute :format, :string
+        attribute :required, :boolean
+        attribute :default, :string
+        attribute :pattern, :string
+        attribute :enum, :string, collection: true
+        attribute :ref, :string
+        attribute :min_length, :integer
+        attribute :max_length, :integer
+        attribute :minimum, :float
+        attribute :maximum, :float
+        attribute :items_type, :string
+        attribute :deprecated, :boolean
+        attribute :examples, :string, collection: true
+
+        json do
+          map "name", to: :name
+          map "title", to: :title
+          map "description", to: :description
+          map "type", to: :type
+          map "format", to: :format
+          map "required", to: :required
+          map "default", to: :default
+          map "pattern", to: :pattern
+          map "enum", to: :enum
+          map "$ref", to: :ref
+          map "minLength", to: :min_length
+          map "maxLength", to: :max_length
+          map "minimum", to: :minimum
+          map "maximum", to: :maximum
+          map "itemsType", to: :items_type
+          map "deprecated", to: :deprecated
+          map "examples", to: :examples
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/spa_schema.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaSchema < Base
+        attribute :name, :string
+        attribute :title, :string
+        attribute :description, :string
+        attribute :type, :string
+        attribute :properties, SpaProperty, collection: true, initialize_empty: true
+        attribute :definitions, SpaDefinition, collection: true, initialize_empty: true
+        attribute :required, :string, collection: true
+        attribute :examples, :string, collection: true
+
+        json do
+          map "name", to: :name
+          map "title", to: :title
+          map "description", to: :description
+          map "type", to: :type
+          map "properties", to: :properties
+          map "definitions", to: :definitions
+          map "required", to: :required
+          map "examples", to: :examples
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/spa_search_entry.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class SpaSearchEntry < Base
+        attribute :name, :string
+        attribute :title, :string
+        attribute :type, :string
+        attribute :schema_name, :string
+
+        json do
+          map "name", to: :name
+          map "title", to: :title
+          map "type", to: :type
+          map "schemaName", to: :schema_name
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/spa/vue_inlined_strategy.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class VueInlinedStrategy < OutputStrategy
+        FRONTEND_DIST = File.expand_path("../../../../frontend/dist", __dir__)
+
+        def write(json_data)
+          FileUtils.mkdir_p(@output_path)
+
+          js = read_frontend_asset("app.iife.js")
+          css = read_frontend_asset("style.css")
+
+          html = build_html(json_data, js, css)
+
+          File.write(File.join(@output_path, "index.html"), html)
+        end
+
+        private
+
+        def read_frontend_asset(filename)
+          path = File.join(FRONTEND_DIST, filename)
+          return File.read(path) if File.exist?(path)
+
+          raise Error, "Frontend asset not found: #{path}. Run `bundle exec rake build_frontend` first."
+        end
+
+        def build_html(json_data, js, css)
+          <<~HTML
+            <!DOCTYPE html>
+            <html lang="en">
+            <head>
+              <meta charset="UTF-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              <title>JSON Schema Documentation</title>
+              <style>#{css}</style>
+            </head>
+            <body>
+              <div id="app"></div>
+              <script>window.SCHEMA_DATA = #{json_data};</script>
+              <script>#{js}</script>
+            </body>
+            </html>
+          HTML
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    VERSION = "0.1.0"
+  end
+end

data/lib/lutaml/jsonschema.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "jsonschema/version"
+require "lutaml/model"
+
+module Lutaml
+  module Jsonschema
+    class Error < StandardError; end
+  end
+end
+
+require_relative "jsonschema/base"
+require_relative "jsonschema/link"
+require_relative "jsonschema/property_entry"
+require_relative "jsonschema/schema"
+require_relative "jsonschema/reference_resolver"
+require_relative "jsonschema/schema_set"
+require_relative "jsonschema/combiner"
+require_relative "jsonschema/spa/metadata"
+require_relative "jsonschema/spa/spa_property"
+require_relative "jsonschema/spa/spa_definition"
+require_relative "jsonschema/spa/spa_schema"
+require_relative "jsonschema/spa/spa_search_entry"
+require_relative "jsonschema/spa/spa_builder"
+require_relative "jsonschema/spa/spa_document"
+require_relative "jsonschema/spa/output_strategy"
+require_relative "jsonschema/spa/vue_inlined_strategy"
+require_relative "jsonschema/spa/generator"
+require_relative "jsonschema/configuration"

data/sig/lutaml/jsonschema.rbs

@@ -0,0 +1,6 @@
+module Lutaml
+  module Jsonschema
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: lutaml-jsonschema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Parse JSON Schema files into LutaML model objects and generate SPA documentation
+  sites
+email:
+- open.source@ribose.com
+executables:
+- lutaml-jsonschema
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- README.md
+- Rakefile
+- exe/lutaml-jsonschema
+- frontend/index.html
+- frontend/package-lock.json
+- frontend/package.json
+- frontend/public/lutaml-logo-dark.svg
+- frontend/public/lutaml-logo-full-dark.svg
+- frontend/public/lutaml-logo-full-light.svg
+- frontend/public/lutaml-logo-light.svg
+- frontend/src/App.vue
+- frontend/src/__tests__/useBuilderField.test.ts
+- frontend/src/__tests__/useDefinitionResolver.test.ts
+- frontend/src/__tests__/useSchemaTypes.test.ts
+- frontend/src/app.ts
+- frontend/src/components/AppHeader.vue
+- frontend/src/components/AppSidebar.vue
+- frontend/src/components/DetailPanel.vue
+- frontend/src/components/SchemaBuilder.vue
+- frontend/src/components/SchemaStructure.vue
+- frontend/src/components/SearchModal.vue
+- frontend/src/composables/useBuilderField.ts
+- frontend/src/composables/useDefinitionResolver.ts
+- frontend/src/composables/useSchemaTypes.ts
+- frontend/src/composables/useSearch.ts
+- frontend/src/router.ts
+- frontend/src/stores/schemaStore.ts
+- frontend/src/stores/uiStore.ts
+- frontend/src/style.css
+- frontend/src/types.ts
+- frontend/src/views/HomeView.vue
+- frontend/tsconfig.json
+- frontend/vite.config.ts
+- lib/lutaml/jsonschema.rb
+- lib/lutaml/jsonschema/base.rb
+- lib/lutaml/jsonschema/cli.rb
+- lib/lutaml/jsonschema/combiner.rb
+- lib/lutaml/jsonschema/configuration.rb
+- lib/lutaml/jsonschema/link.rb
+- lib/lutaml/jsonschema/property_entry.rb
+- lib/lutaml/jsonschema/reference_resolver.rb
+- lib/lutaml/jsonschema/schema.rb
+- lib/lutaml/jsonschema/schema_set.rb
+- lib/lutaml/jsonschema/spa/generator.rb
+- lib/lutaml/jsonschema/spa/metadata.rb
+- lib/lutaml/jsonschema/spa/output_strategy.rb
+- lib/lutaml/jsonschema/spa/spa_builder.rb
+- lib/lutaml/jsonschema/spa/spa_definition.rb
+- lib/lutaml/jsonschema/spa/spa_document.rb
+- lib/lutaml/jsonschema/spa/spa_property.rb
+- lib/lutaml/jsonschema/spa/spa_schema.rb
+- lib/lutaml/jsonschema/spa/spa_search_entry.rb
+- lib/lutaml/jsonschema/spa/vue_inlined_strategy.rb
+- lib/lutaml/jsonschema/version.rb
+- sig/lutaml/jsonschema.rbs
+homepage: https://github.com/lutaml/lutaml-jsonschema
+licenses: []
+metadata:
+  homepage_uri: https://github.com/lutaml/lutaml-jsonschema
+  source_code_uri: https://github.com/lutaml/lutaml-jsonschema
+  changelog_uri: https://github.com/lutaml/lutaml-jsonschema/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: JSON Schema model representation and SPA documentation generator
+test_files: []