lutaml-jsonschema 0.1.0

data/lib/lutaml/jsonschema/reference_resolver.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    class ReferenceResolver
+      def initialize(schemas = {})
+        @schemas = schemas
+      end
+
+      def resolve(ref, root_schema = nil)
+        return nil unless ref
+
+        if ref.start_with?("#/")
+          resolve_local(ref, root_schema)
+        else
+          resolve_remote(ref)
+        end
+      end
+
+      def resolve_local(ref, schema)
+        parts = ref.delete_prefix("#/").split("/")
+        current = schema
+
+        parts.each do |part|
+          case current
+          when Schema
+            current = navigate_schema(current, part)
+          when Array
+            entry = current.find { |e| e.is_a?(PropertyEntry) && e.name == part }
+            current = entry&.schema
+          else
+            return nil
+          end
+          return nil unless current
+        end
+
+        current.is_a?(Schema) && current.dollar_ref ? resolve(current.dollar_ref, schema) : current
+      end
+
+      def resolve_remote(ref)
+        return nil unless @schemas
+
+        if ref.include?("#")
+          file_path, fragment = ref.split("#", 2)
+          schema = @schemas[file_path]
+          schema ? resolve_local("##{fragment}", schema) : nil
+        else
+          @schemas[ref]
+        end
+      end
+
+      private
+
+      def navigate_schema(schema, part)
+        case part
+        when "definitions", "$defs"
+          schema.definition_entries
+        when "properties"
+          schema.property_entries
+        when "patternProperties"
+          schema.pattern_property_entries
+        when "items"
+          schema.items
+        when "allOf" then schema.all_of
+        when "anyOf" then schema.any_of
+        when "oneOf" then schema.one_of
+        else
+          entries = schema.definition_entries || []
+          entries.find { |e| e.name == part }&.schema
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/schema.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    class Schema < Base
+      # Document-level keywords
+      attribute :dollar_schema, :string
+      attribute :dollar_id, :string
+      attribute :dollar_ref, :string
+      attribute :dollar_comment, :string
+      attribute :dollar_anchor, :string
+
+      # Metadata
+      attribute :title, :string
+      attribute :description, :string
+      attribute :default, :string
+      attribute :examples, :string, collection: true
+      attribute :deprecated, :boolean
+      attribute :read_only, :boolean
+      attribute :write_only, :boolean
+
+      # Type keywords
+      attribute :type, :string
+      attribute :format, :string
+
+      # Object keywords
+      attribute :property_entries, PropertyEntry, collection: true, initialize_empty: true
+      attribute :pattern_property_entries, PropertyEntry, collection: true, initialize_empty: true
+      attribute :required, :string, collection: true, initialize_empty: true
+      attribute :additional_properties, :boolean
+      attribute :additional_properties_schema, Schema
+      attribute :min_properties, :integer
+      attribute :max_properties, :integer
+
+      # Array keywords
+      attribute :items, Schema
+      attribute :min_items, :integer
+      attribute :max_items, :integer
+      attribute :unique_items, :boolean
+      attribute :contains, Schema
+
+      # Numeric keywords
+      attribute :minimum, :float
+      attribute :maximum, :float
+      attribute :exclusive_minimum, :float
+      attribute :exclusive_maximum, :float
+      attribute :multiple_of, :float
+
+      # String keywords
+      attribute :min_length, :integer
+      attribute :max_length, :integer
+      attribute :pattern, :string
+      attribute :content_type, :string
+      attribute :content_encoding, :string
+
+      # Enum / const
+      attribute :enum, :string, collection: true
+      attribute :const, :string
+
+      # Composition (recursive)
+      attribute :all_of, Schema, collection: true, initialize_empty: true
+      attribute :any_of, Schema, collection: true, initialize_empty: true
+      attribute :one_of, Schema, collection: true, initialize_empty: true
+      attribute :not_schema, Schema
+
+      # Conditional
+      attribute :if_schema, Schema
+      attribute :then_schema, Schema
+      attribute :else_schema, Schema
+
+      # Definitions ($defs / definitions)
+      attribute :definition_entries, PropertyEntry, collection: true, initialize_empty: true
+
+      # Hyper-schema links
+      attribute :links, Link, collection: true, initialize_empty: true
+
+      json do
+        map "$schema", to: :dollar_schema
+        map ["$id", "id"], to: :dollar_id
+        map "$ref", to: :dollar_ref
+        map "$comment", to: :dollar_comment
+        map "$anchor", to: :dollar_anchor
+        map "title", to: :title
+        map "description", to: :description
+        map "default", to: :default
+        map ["examples", "example"], to: :examples
+        map "deprecated", to: :deprecated
+        map "readOnly", to: :read_only
+        map "writeOnly", to: :write_only
+        map "type", to: :type,
+                   with: { from: :parse_type, to: :serialize_type }
+        map "format", to: :format
+        map "properties", to: :property_entries,
+                          child_mappings: { name: :key, schema: :value }
+        map "patternProperties", to: :pattern_property_entries,
+                                  child_mappings: { name: :key, schema: :value }
+        map "required", to: :required
+        map "additionalProperties", to: :additional_properties,
+                                   with: { from: :parse_additional_properties,
+                                           to: :serialize_additional_properties }
+        map "minProperties", to: :min_properties
+        map "maxProperties", to: :max_properties
+        map "items", to: :items
+        map "minItems", to: :min_items
+        map "maxItems", to: :max_items
+        map "uniqueItems", to: :unique_items
+        map "contains", to: :contains
+        map "minimum", to: :minimum
+        map "maximum", to: :maximum
+        map "exclusiveMinimum", to: :exclusive_minimum
+        map "exclusiveMaximum", to: :exclusive_maximum
+        map "multipleOf", to: :multiple_of
+        map "minLength", to: :min_length
+        map "maxLength", to: :max_length
+        map "pattern", to: :pattern
+        map "contentMediaType", to: :content_type
+        map "contentEncoding", to: :content_encoding
+        map "enum", to: :enum
+        map "const", to: :const
+        map "allOf", to: :all_of
+        map "anyOf", to: :any_of
+        map "oneOf", to: :one_of
+        map "not", to: :not_schema
+        map "if", to: :if_schema
+        map "then", to: :then_schema
+        map "else", to: :else_schema
+        map "$defs", to: :definition_entries,
+                     child_mappings: { name: :key, schema: :value }
+        map "definitions", to: :definition_entries,
+                           with: { from: :parse_legacy_definitions, to: :noop_serializer }
+        map "links", to: :links
+      end
+
+      def parse_type(instance, value)
+        instance.type = value.is_a?(Array) ? value.join(",") : value
+      end
+
+      def serialize_type(instance, hash)
+        t = instance.type
+        return unless t
+
+        parts = t.split(",")
+        hash["type"] = parts.length == 1 ? parts.first : parts
+      end
+
+      def parse_additional_properties(instance, value)
+        case value
+        when true, false
+          instance.additional_properties = value
+        when Hash
+          instance.additional_properties_schema = Schema.from_json(value.to_json)
+        end
+      end
+
+      def serialize_additional_properties(instance, hash)
+        if instance.additional_properties_schema
+          hash["additionalProperties"] = JSON.parse(instance.additional_properties_schema.to_json)
+        elsif !instance.additional_properties.nil?
+          hash["additionalProperties"] = instance.additional_properties
+        end
+      end
+
+      def object?
+        types.include?("object")
+      end
+
+      def array?
+        types.include?("array")
+      end
+
+      def types
+        return [] unless type
+
+        type.split(",")
+      end
+
+      def ref?
+        !!dollar_ref
+      end
+
+      def all_property_entries
+        result = property_entries.dup
+        all_of.each { |s| result.concat(s.all_property_entries) }
+        result
+      end
+
+      def noop_serializer(_instance, _hash); end
+
+      def parse_legacy_definitions(instance, value)
+        return unless value.is_a?(Hash)
+
+        value.each do |name, schema_hash|
+          next if instance.definition_entries.any? { |e| e.name == name }
+
+          instance.definition_entries.push(
+            PropertyEntry.new(
+              name: name,
+              schema: Schema.from_json(schema_hash.to_json)
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/jsonschema/schema_set.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    class SchemaSet
+      attr_reader :schemas, :base_dir
+
+      def initialize(base_dir: nil)
+        @schemas = {}
+        @base_dir = base_dir
+        @resolver = ReferenceResolver.new(@schemas)
+      end
+
+      def self.load_from_files(*paths, base_dir: nil)
+        set = new(base_dir: base_dir || infer_base_dir(paths))
+        paths.each do |path|
+          data = File.read(path)
+          schema = Schema.from_json(data)
+          name = File.basename(path, ".*")
+          set.add(name, schema, path)
+        end
+        set
+      end
+
+      def self.load_from_directory(dir)
+        paths = Dir.glob(File.join(dir, "*.json"))
+        load_from_files(*paths, base_dir: dir)
+      end
+
+      def add(name, schema, file_path = nil)
+        @schemas[name] = schema
+        return unless file_path
+
+        @file_paths ||= {}
+        @file_paths[File.basename(file_path)] = file_path
+      end
+
+      def resolve_ref(ref_string, context_schema = nil)
+        return nil unless ref_string
+
+        if ref_string.start_with?("./")
+          resolve_file_ref(ref_string, context_schema)
+        elsif ref_string.start_with?("http://", "https://")
+          resolve_remote_ref(ref_string)
+        elsif ref_string.start_with?("#/")
+          @resolver.resolve(ref_string, context_schema)
+        elsif ref_string.start_with?("#") && !ref_string.start_with?("#/")
+          resolve_anchor_ref(ref_string.delete_prefix("#"), context_schema)
+        else
+          @resolver.resolve(ref_string, context_schema)
+        end
+      end
+
+      def validate!
+        errors = []
+        seen_refs = Set.new
+
+        @schemas.each do |name, schema|
+          collect_refs(schema, name, errors, seen_refs, "")
+        end
+
+        raise ValidationError, errors.join("\n") if errors.any?
+
+        true
+      end
+
+      def valid?
+        validate! rescue false
+      end
+
+      def all_definitions
+        @schemas.flat_map do |_name, schema|
+          schema.definition_entries
+        end
+      end
+
+      def all_properties
+        @schemas.flat_map do |_name, schema|
+          schema.property_entries
+        end
+      end
+
+      def validation_errors
+        errors = []
+        @schemas.each do |name, schema|
+          collect_refs(schema, name, errors, Set.new, "")
+        end
+        errors
+      end
+
+      private
+
+      def self.infer_base_dir(paths)
+        return nil if paths.empty?
+
+        File.dirname(paths.first)
+      end
+
+      def resolve_file_ref(ref, context_schema)
+        return nil unless context_schema
+
+        target_file = ref.sub(%r{^\./}, "")
+        schema = find_schema_by_filename(target_file)
+        return schema if schema
+
+        # Try loading from base_dir
+        if @base_dir
+          path = File.join(@base_dir, target_file)
+          if File.exist?(path)
+            loaded = Schema.from_json(File.read(path))
+            add(File.basename(target_file, ".*"), loaded, path)
+            return loaded
+          end
+        end
+
+        nil
+      end
+
+      def resolve_remote_ref(ref)
+        return nil
+
+        # Remote refs are not resolved — would need HTTP fetching
+      end
+
+      def resolve_anchor_ref(anchor, context_schema)
+        return nil unless context_schema
+
+        find_anchor(context_schema, anchor)
+      end
+
+      def find_anchor(schema, anchor)
+        return schema if schema.dollar_anchor == anchor
+
+        [
+          schema.property_entries, schema.definition_entries,
+          schema.pattern_property_entries, schema.all_of,
+          schema.any_of, schema.one_of
+        ].each do |entries|
+          entries.each do |entry|
+            next if entry.nil?
+
+            child = entry.is_a?(PropertyEntry) ? entry.schema : entry
+            next if child.nil?
+
+            found = find_anchor(child, anchor)
+            return found if found
+          end
+        end
+
+        [schema.items, schema.not_schema, schema.if_schema,
+         schema.then_schema, schema.else_schema].each do |child|
+          next if child.nil?
+
+          found = find_anchor(child, anchor)
+          return found if found
+        end
+
+        nil
+      end
+
+      def find_schema_by_filename(filename)
+        # Check if we already loaded this file
+        @schemas.each do |name, schema|
+          return schema if name == File.basename(filename, ".*")
+        end
+
+        # Check file_paths mapping
+        return nil unless @file_paths&.key?(filename)
+
+        name = File.basename(filename, ".*")
+        @schemas[name]
+      end
+
+      def collect_refs(schema, source_name, errors, seen_refs, path)
+        ref = schema.dollar_ref
+        if ref && !seen_refs.include?("#{source_name}:#{path}:#{ref}")
+          seen_refs.add("#{source_name}:#{path}:#{ref}")
+          resolved = resolve_ref(ref, @schemas[source_name])
+          errors << "#{source_name}#{path}: unresolvable $ref '#{ref}'" if resolved.nil? && ref.start_with?("#/", "./")
+        end
+
+        children = [
+          [:property_entries, schema.property_entries],
+          [:definition_entries, schema.definition_entries],
+          [:pattern_property_entries, schema.pattern_property_entries],
+        ]
+        children.each do |key, entries|
+          entries.each do |entry|
+            collect_refs(entry.schema, source_name, errors, seen_refs, "#{path}/#{key}/#{entry.name}")
+          end
+        end
+
+        schema.all_of.each_with_index { |s, i| collect_refs(s, source_name, errors, seen_refs, "#{path}/allOf[#{i}]") }
+        schema.any_of.each_with_index { |s, i| collect_refs(s, source_name, errors, seen_refs, "#{path}/anyOf[#{i}]") }
+        schema.one_of.each_with_index { |s, i| collect_refs(s, source_name, errors, seen_refs, "#{path}/oneOf[#{i}]") }
+
+        single_children = {
+          items: schema.items,
+          not_schema: schema.not_schema,
+          if_schema: schema.if_schema,
+          then_schema: schema.then_schema,
+          else_schema: schema.else_schema,
+        }
+        single_children.each do |attr, child|
+          collect_refs(child, source_name, errors, seen_refs, "#{path}/#{attr}") if child
+        end
+
+        schema.links.each do |link|
+          collect_refs(link.schema, source_name, errors, seen_refs, "#{path}/link.schema") if link.schema
+          collect_refs(link.target_schema, source_name, errors, seen_refs, "#{path}/link.target_schema") if link.target_schema
+        end
+      end
+
+      class ValidationError < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class Generator
+        def initialize(schema_set, output_path, metadata: Metadata.new, strategy: nil)
+          @schema_set = schema_set
+          @output_path = output_path
+          @metadata = metadata
+          @strategy = strategy || VueInlinedStrategy.new(@output_path)
+        end
+
+        def generate
+          document = SpaBuilder.new(@schema_set, metadata: @metadata).build
+          json_data = document.to_json
+          @strategy.write(json_data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class Metadata < Base
+        attribute :title, :string
+        attribute :version, :string
+        attribute :description, :string
+        attribute :base_url, :string
+        attribute :theme, :string, default: "light"
+
+        json do
+          map "title", to: :title
+          map "version", to: :version
+          map "description", to: :description
+          map "baseUrl", to: :base_url
+          map "theme", to: :theme
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Jsonschema
+    module Spa
+      class OutputStrategy
+        def initialize(output_path)
+          @output_path = output_path
+        end
+
+        def write(_json_data)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end