schemaforge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c62b91be85dba818c0260c7ba4b48dcc3f07ba741b723e88dae713b7b145f96
+  data.tar.gz: 72d41eef0776df16199b1e41caaf468c2d43550806fd16ac51021d79e56db581
+SHA512:
+  metadata.gz: 1e6be4fdcee6980b73b2eda3d682b9d3c8399b16ed9965b1bbac21d7526ca3f2bcff36abbc7385280fca9c22ddcc8ae3f79104c0da249adca1eedcbd27b66da3
+  data.tar.gz: 541defa841034c0c28ab0ac2642d0fc91ce88c838cbbf25066c751cc5b7648f6b953f5d90da827b299f894222c2bea934f41ff75ff374baf99d22f7fa483edc8

data/LICENSE.txt

@@ -0,0 +1,19 @@
+MIT License
+
+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/README.md

@@ -0,0 +1,25 @@
+# SchemaForge
+
+Generate Ruby `Data.define` value objects from XSD (XML Schema) files.
+
+## Status
+
+Released. The design is documented in the repository.
+
+## Usage
+
+```ruby
+require "schema_forge"
+
+SchemaForge.generate(
+  input: "schemas/",
+  output: "lib/generated",
+  module_name: "Schema",
+)
+```
+
+CLI:
+
+```sh
+schema_forge schemas/ --out lib/generated --module Schema
+```

data/exe/schemaforge

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "optparse"
+require "schema_forge"
+
+options = { module_name: "Schema", out: "schema_forge_out", fetch_remote: true }
+parser = OptionParser.new do |o|
+  o.banner = "Usage: schemaforge <input> [options]"
+  o.on("--out DIR",       "Output directory (default: schema_forge_out)") { |v| options[:out] = v }
+  o.on("--module NAME",   "Module wrapping generated types (default: Schema)") { |v| options[:module_name] = v }
+  o.on("--[no-]fetch-remote", "Fetch remote xs:import/include (default: yes)") { |v| options[:fetch_remote] = v }
+  o.on("--version", "Print version and exit") do
+    puts SchemaForge::VERSION
+    exit 0
+  end
+  o.on("-h", "--help", "Print this help and exit") do
+    puts o
+    exit 0
+  end
+end
+
+remaining = parser.parse!
+input = remaining.shift
+if input.nil?
+  warn parser
+  exit 1
+end
+
+begin
+  SchemaForge.generate(
+    input: input,
+    output: options[:out],
+    module_name: options[:module_name],
+    fetch_remote: options[:fetch_remote]
+  )
+  puts "done"
+rescue SchemaForge::Error => e
+  warn "schema_forge: #{e.message}"
+  warn "  source: #{e.source}" if e.source
+  exit 1
+end

data/lib/schema_forge/builtin_types.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  module BuiltinTypes
+    XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
+
+    STRING_TYPES = %w[
+      string anyURI QName NOTATION normalizedString token language
+      Name NCName ID IDREF IDREFS ENTITY ENTITIES NMTOKEN NMTOKENS
+      base64Binary hexBinary
+      date dateTime time duration gDay gMonth gMonthDay gYear gYearMonth
+    ].freeze
+
+    INTEGER_TYPES = %w[
+      byte short int long integer negativeInteger nonNegativeInteger
+      nonPositiveInteger positiveInteger
+      unsignedByte unsignedShort unsignedInt unsignedLong
+    ].freeze
+
+    FLOAT_TYPES = %w[decimal float double].freeze
+
+    BOOLEAN_TYPES = %w[boolean].freeze
+
+    MAPPING = STRING_TYPES.to_h { |t| [t, "String"] }.merge(
+      INTEGER_TYPES.to_h { |t| [t, "Integer"] }
+    ).merge(
+      FLOAT_TYPES.to_h   { |t| [t, "Float"] }
+    ).merge(
+      BOOLEAN_TYPES.to_h { |t| [t, "Object"] }
+    ).freeze
+
+    module_function
+
+    def ruby_type_for(namespace, local_name)
+      return nil unless namespace == XSD_NAMESPACE
+
+      MAPPING[local_name]
+    end
+
+    def builtin?(namespace, local_name)
+      !ruby_type_for(namespace, local_name).nil?
+    end
+  end
+end

data/lib/schema_forge/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  class Error < StandardError
+    attr_reader :source
+
+    def initialize(message = nil, source: nil)
+      super(message)
+      @source = source
+    end
+  end
+
+  class ParseError    < Error; end
+  class ResolveError  < Error; end
+  class FetchError    < Error; end
+  class GenerateError < Error; end
+end

data/lib/schema_forge/generator.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require_relative "naming"
+
+module SchemaForge
+  class Generator
+    HEADER = <<~HEADER
+      # Code generated by SchemaForge. DO NOT EDIT.
+      # frozen_string_literal: true
+    HEADER
+
+    def initialize(module_name:, hooks: nil)
+      @module_name = module_name
+      @hooks = hooks
+    end
+
+    def emit(doc)
+      out = +""
+      out << HEADER
+      out << "\n"
+      out << "module #{@module_name}\n"
+      if doc.types.empty? && doc.elements.empty?
+        out << "  # (no types)\n"
+      else
+        doc.types.each do |t|
+          if @hooks.nil? || @hooks.on_generate(t, self)
+            out << emit_type(t)
+            out << "\n"
+          end
+        end
+      end
+      out << "end\n"
+      @hooks ? @hooks.on_emit_source(out) : out
+    end
+
+    private
+
+    def emit_type(type)
+      case type
+      when Schema::SimpleType  then emit_simple_type(type)
+      when Schema::ComplexType then emit_complex_type(type)
+      else ""
+      end
+    end
+
+    def emit_simple_type(simple)
+      base_ruby_type = ruby_type_for_simple(simple)
+      facets = simple.body.is_a?(Schema::Restriction) ? (simple.body.facets || {}) : {}
+
+      if facets.empty?
+        out = +""
+        out << "  # simpleType: #{simple_base_label(simple)}\n" if simple.body
+        out << "  #{Naming.pascal_case(simple.name)} = #{base_ruby_type}\n"
+        out
+      else
+        emit_simple_wrapper(simple, base_ruby_type, facets)
+      end
+    end
+
+    def emit_simple_wrapper(simple, base_ruby_type, facets)
+      type_name = Naming.pascal_case(simple.name)
+      lines = +""
+      lines << "  # simpleType: #{simple_base_label(simple)}\n"
+      facets.each { |k, v| lines << "  # #{k}: #{Array(v).join(', ')}\n" }
+      lines << "  #{type_name} = Data.define(:value) do\n"
+      lines << "    def initialize(value:)\n"
+      lines << type_check_line(type_name, base_ruby_type)
+      lines << enum_check_line(type_name) if facets[:enumeration]
+      lines << emit_facet_validations(type_name, "value", facets)
+      lines << "      super\n"
+      lines << "    end\n"
+      lines << "  end\n"
+      lines << "  #{type_name}::VALUES = %w[#{facets[:enumeration].join(' ')}].freeze\n" if facets[:enumeration]
+      lines
+    end
+
+    def type_check_line(type_name, base_ruby_type)
+      msg = "#{type_name}#value must be a #{base_ruby_type}"
+      "      raise ArgumentError, \"#{msg}\" unless value.is_a?(#{base_ruby_type})\n"
+    end
+
+    def enum_check_line(type_name)
+      msg = "#{type_name}#value must be one of \#{#{type_name}::VALUES}"
+      "      raise ArgumentError, \"#{msg}\" unless #{type_name}::VALUES.include?(value)\n"
+    end
+
+    def emit_facet_validations(type_name, field, facets)
+      out = +""
+      facets.each do |key, value|
+        line = facet_validation_line(type_name, field, key, value)
+        out << line if line
+      end
+      out
+    end
+
+    def facet_validation_line(type_name, field, key, value)
+      pfx = "#{type_name}##{field}"
+      string_facet_line(pfx, field, key, value) ||
+        numeric_facet_line(pfx, field, key, value)
+      # :enumeration handled separately via constant (T18)
+    end
+
+    def string_facet_line(pfx, field, key, value)
+      case key
+      when :length
+        "      raise ArgumentError, \"#{pfx} length must be #{value}\" " \
+        "unless #{field}.length == #{value}\n"
+      when :min_length
+        "      raise ArgumentError, \"#{pfx} length must be >= #{value}\" " \
+        "if #{field}.length < #{value}\n"
+      when :max_length
+        "      raise ArgumentError, \"#{pfx} length must be <= #{value}\" " \
+        "if #{field}.length > #{value}\n"
+      when :pattern
+        "      raise ArgumentError, \"#{pfx} must match /#{value}/\" " \
+        "unless #{field}.match?(/\\A#{value}\\z/)\n"
+      end
+    end
+
+    def numeric_facet_line(pfx, field, key, value)
+      case key
+      when :min_inclusive
+        "      raise ArgumentError, \"#{pfx} must be >= #{value}\" if #{field} < #{value}\n"
+      when :max_inclusive
+        "      raise ArgumentError, \"#{pfx} must be <= #{value}\" if #{field} > #{value}\n"
+      when :min_exclusive
+        "      raise ArgumentError, \"#{pfx} must be > #{value}\" if #{field} <= #{value}\n"
+      when :max_exclusive
+        "      raise ArgumentError, \"#{pfx} must be < #{value}\" if #{field} >= #{value}\n"
+      when :total_digits then total_digits_line(pfx, field, value)
+      when :fraction_digits then fraction_digits_line(pfx, field, value)
+      end
+    end
+
+    def total_digits_line(pfx, field, value)
+      check = "#{field}.to_s.gsub('-', '').gsub('.', '').length > #{value}"
+      "      raise ArgumentError, \"#{pfx} must have at most #{value} digits\" if #{check}\n"
+    end
+
+    def fraction_digits_line(pfx, field, value)
+      check = "(#{field}.to_s.split('.')[1] || '').length > #{value}"
+      "      raise ArgumentError, \"#{pfx} must have at most #{value} fraction digits\" " \
+        "if #{check}\n"
+    end
+
+    def simple_base_label(simple)
+      case simple.body
+      when Schema::Restriction then simple.body.base ? simple.body.base.local_name : "(unknown)"
+      when Schema::List        then "list of #{simple.body.item_type.local_name}"
+      when Schema::Union       then "union of #{simple.body.member_types.map(&:local_name).join(', ')}"
+      else "(no body)"
+      end
+    end
+
+    def ruby_type_for_simple(simple)
+      case simple.body
+      when Schema::Restriction
+        ref = simple.body.base
+        ref ? (BuiltinTypes.ruby_type_for(ref.namespace, ref.local_name) || "String") : "String"
+      else
+        "String"
+      end
+    end
+
+    def emit_complex_type(complex_type)
+      type_name = Naming.pascal_case(complex_type.name)
+
+      element_fields = collect_element_fields(complex_type)
+      attr_fields    = complex_type.attributes.map { |a| build_attr_field(a) }
+      value_fields   = simple_content_value_fields(complex_type)
+      fields         = attr_fields + value_fields + element_fields
+
+      choice_field_names = collect_choice_field_names(complex_type)
+
+      lines = +""
+      lines << emit_complex_doc(complex_type)
+      lines << "  # choice: exactly one of #{choice_field_names.join(', ')}\n" if choice_field_names
+      lines << "  #{type_name} = Data.define(#{fields.map { |f| ":#{f[:name]}" }.join(', ')})"
+      lines << " do\n"
+      lines << "    def initialize(#{kwargs_for(fields)})\n"
+      lines << emit_choice_validation(type_name, choice_field_names) if choice_field_names
+      fields.each { |f| lines << emit_field_validation(type_name, f) }
+      lines << "      super\n"
+      lines << "    end\n"
+      lines << "  end\n"
+      lines
+    end
+
+    def collect_choice_field_names(complex_type)
+      return nil unless complex_type.content.is_a?(Schema::Choice) && !repeating?(complex_type.content)
+
+      complex_type.content.items.filter_map { |i| Naming.snake_case(i.name) if i.is_a?(Schema::Element) }
+    end
+
+    def emit_choice_validation(type_name, choice_field_names)
+      names_array = "[#{choice_field_names.join(', ')}]"
+      msg = "#{type_name}: exactly one of #{choice_field_names.join(', ')} must be set"
+      out = +""
+      out << "      set = #{names_array}.count { |v| !v.nil? }\n"
+      out << "      raise ArgumentError, \"#{msg}\" unless set == 1\n"
+      out
+    end
+
+    def emit_complex_doc(complex_type)
+      out = +""
+      emit_complex_doc_annotations(out, complex_type)
+      out << "  # mixed content\n" if complex_type.mixed
+      if complex_type.derivation == :extension && complex_type.base
+        out << "  # extends #{complex_type.base.local_name}\n"
+      end
+      out
+    end
+
+    def emit_complex_doc_annotations(out, complex_type)
+      return unless complex_type.doc
+
+      out << "  # #{complex_type.doc[:appinfo]}\n"       if complex_type.doc[:appinfo]
+      out << "  # #{complex_type.doc[:documentation]}\n" if complex_type.doc[:documentation]
+    end
+
+    def simple_content_extension?(complex_type)
+      complex_type.derivation == :extension && complex_type.base && complex_type.content.nil?
+    end
+
+    def simple_content_value_fields(complex_type)
+      return [] unless simple_content_extension?(complex_type)
+
+      ruby_type = BuiltinTypes.ruby_type_for(complex_type.base.namespace, complex_type.base.local_name) ||
+                  Naming.pascal_case(complex_type.base.local_name)
+      [{
+        name: "value",
+        ruby_type: ruby_type,
+        list: false,
+        optional: false,
+        source: :element,
+        min_occurs: 1,
+        max_occurs: 1
+      }]
+    end
+
+    def collect_element_fields(complex_type)
+      case complex_type.content
+      when Schema::Sequence
+        repeating = repeating?(complex_type.content)
+        seq_min   = complex_type.content.min_occurs
+        seq_max   = complex_type.content.max_occurs
+        complex_type.content.items.flat_map do |item|
+          element_field_for(item, sequence_repeats: repeating, seq_min: seq_min, seq_max: seq_max)
+        end
+      when Schema::Choice
+        repeating = repeating?(complex_type.content)
+        choice_optional = !repeating
+        complex_type.content.items.flat_map do |item|
+          element_field_for(item, sequence_repeats: repeating, choice_optional: choice_optional)
+        end
+      else
+        []
+      end
+    end
+
+    def repeating?(content)
+      content.max_occurs == :unbounded || (content.max_occurs.is_a?(Integer) && content.max_occurs > 1)
+    end
+
+    def element_field_for(particle, sequence_repeats:, choice_optional: false, seq_min: nil, seq_max: nil)
+      case particle
+      when Schema::Element
+        element_fields_for_element(particle, sequence_repeats, choice_optional, seq_min, seq_max)
+      when Schema::Choice
+        element_fields_for_choice(particle)
+      when Schema::Any
+        [{ name: "any", ruby_type: nil, list: false, optional: true, source: :any, min_occurs: 0, max_occurs: 1 }]
+      else
+        []
+      end
+    end
+
+    def element_fields_for_element(particle, sequence_repeats, choice_optional, seq_min, seq_max)
+      list = list_element?(particle, sequence_repeats)
+      optional = choice_optional || (particle.min_occurs.zero? && !list)
+      eff_min = list && !seq_min.nil? ? seq_min : particle.min_occurs
+      eff_max = list && !seq_max.nil? ? seq_max : particle.max_occurs
+      [{
+        name: Naming.snake_case(particle.name),
+        ruby_type: ruby_type_for_ref(particle.type_ref),
+        list: list,
+        optional: optional,
+        source: :element,
+        min_occurs: eff_min,
+        max_occurs: eff_max
+      }]
+    end
+
+    def element_fields_for_choice(particle)
+      choice_repeating = repeating?(particle)
+      particle.items.flat_map do |item|
+        element_field_for(
+          item,
+          sequence_repeats: choice_repeating,
+          choice_optional: !choice_repeating,
+          seq_min: particle.min_occurs,
+          seq_max: particle.max_occurs
+        )
+      end
+    end
+
+    def list_element?(particle, sequence_repeats)
+      sequence_repeats || particle.max_occurs == :unbounded ||
+        (particle.max_occurs.is_a?(Integer) && particle.max_occurs > 1)
+    end
+
+    def build_attr_field(attr)
+      ruby_type = if attr.type_ref
+                    BuiltinTypes.ruby_type_for(attr.type_ref.namespace, attr.type_ref.local_name) ||
+                      Naming.pascal_case(attr.type_ref.local_name)
+                  end
+      {
+        name: Naming.attr_field(attr.name),
+        ruby_type: ruby_type,
+        list: false,
+        optional: attr.use != :required,
+        source: :attribute,
+        use: attr.use
+      }
+    end
+
+    def kwargs_for(fields)
+      fields.map do |f|
+        if f[:list]
+          "#{f[:name]}: []"
+        elsif f[:optional]
+          "#{f[:name]}: nil"
+        else
+          "#{f[:name]}:"
+        end
+      end.join(", ")
+    end
+
+    def emit_field_validation(type_name, field)
+      return "" if field[:ruby_type].nil?
+
+      if field[:list]
+        emit_list_field_validation(type_name, field)
+      elsif field[:optional]
+        emit_optional_field_validation(type_name, field)
+      else
+        emit_required_field_validation(type_name, field)
+      end
+    end
+
+    def emit_list_field_validation(type_name, field)
+      ruby_type = field[:ruby_type]
+      label = "#{type_name}##{field[:name]}"
+      out = +""
+      out << "      raise ArgumentError, \"#{label} must be an Array\" unless #{field[:name]}.is_a?(Array)\n"
+      out << "      raise ArgumentError, \"#{label} elements must be #{ruby_type}\" " \
+             "unless #{field[:name]}.all? { |e| e.is_a?(#{ruby_type}) }\n"
+      if field[:min_occurs].is_a?(Integer) && field[:min_occurs].positive?
+        out << "      raise ArgumentError, \"#{label} must have at least #{field[:min_occurs]} element(s)\" " \
+               "if #{field[:name]}.size < #{field[:min_occurs]}\n"
+      end
+      if field[:max_occurs].is_a?(Integer)
+        out << "      raise ArgumentError, \"#{label} must have at most #{field[:max_occurs]} element(s)\" " \
+               "if #{field[:name]}.size > #{field[:max_occurs]}\n"
+      end
+      out
+    end
+
+    def emit_optional_field_validation(type_name, field)
+      ruby_type = field[:ruby_type]
+      label = "#{type_name}##{field[:name]}"
+      article = ruby_type =~ /\A[AEIOU]/ ? "" : "a "
+      "      raise ArgumentError, \"#{label} must be #{article}#{ruby_type} or nil\" " \
+        "unless #{field[:name]}.nil? || #{field[:name]}.is_a?(#{ruby_type})\n"
+    end
+
+    def emit_required_field_validation(type_name, field)
+      ruby_type = field[:ruby_type]
+      label = "#{type_name}##{field[:name]}"
+      article = ruby_type =~ /\A[AEIOU]/ ? "an" : "a"
+      "      raise ArgumentError, \"#{label} must be #{article} #{ruby_type}\" " \
+        "unless #{field[:name]}.is_a?(#{ruby_type})\n"
+    end
+
+    def ruby_type_for_ref(ref)
+      return nil if ref.nil?
+
+      BuiltinTypes.ruby_type_for(ref.namespace, ref.local_name) || Naming.pascal_case(ref.local_name)
+    end
+  end
+end

data/lib/schema_forge/hooks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  module Hooks
+    class Base
+      def on_complex_type(_node, _schema)
+        true
+      end
+
+      def on_simple_type(_node, _schema)
+        true
+      end
+
+      def on_element(_node, _schema)
+        true
+      end
+
+      def on_attribute(_node, _schema)
+        true
+      end
+
+      def on_annotation(_node, _schema)
+        true
+      end
+
+      def on_generate(_type, _generator)
+        true
+      end
+
+      def on_emit_source(source)
+        source
+      end
+    end
+  end
+end