schemaforge 0.1.0

data/lib/schema_forge/resolver.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  class Resolver
+    def self.resolve(doc)
+      new(doc).resolve
+    end
+
+    def initialize(doc)
+      @doc = doc
+      @target_ns = doc.target_namespace
+      @promoted = []
+      @existing_names = doc.types.filter_map(&:name).to_set
+    end
+
+    def resolve
+      new_types = @doc.types.map { |t| promote_within(t, parent_name: t.name) }
+      new_elements = @doc.elements.map { |e| promote_in_element(e, parent_name: e.name) }
+      @doc = Schema::Document.new(
+        target_namespace: @doc.target_namespace,
+        namespaces: @doc.namespaces,
+        types: new_types + @promoted,
+        elements: new_elements,
+        groups: @doc.groups,
+        attribute_groups: @doc.attribute_groups,
+        imports: @doc.imports,
+        includes: @doc.includes
+      )
+      expand_groups_and_flatten_extensions
+      @types_by_qname = build_index
+      check_all_type_refs
+      @doc
+    end
+
+    private
+
+    def index_groups
+      @doc.groups.to_h { |g| [[@target_ns, g.name], g] }
+    end
+
+    def index_attribute_groups
+      @doc.attribute_groups.to_h { |ag| [[@target_ns, ag.name], ag] }
+    end
+
+    def expand_groups_and_flatten_extensions
+      groups_idx = index_groups
+      ag_idx = index_attribute_groups
+
+      new_types = @doc.types.map { |t| expand_in_type(t, groups_idx, ag_idx) }
+      new_types = new_types.map { |t| flatten_extension(t, new_types, ag_idx) }
+
+      @doc = Schema::Document.new(
+        target_namespace: @doc.target_namespace,
+        namespaces: @doc.namespaces,
+        types: new_types,
+        elements: @doc.elements,
+        groups: @doc.groups,
+        attribute_groups: @doc.attribute_groups,
+        imports: @doc.imports,
+        includes: @doc.includes
+      )
+    end
+
+    def expand_in_type(type, groups_idx, ag_idx)
+      return type unless type.is_a?(Schema::ComplexType)
+
+      new_attributes = type.attributes + ag_refs_to_attributes(type.attribute_groups, ag_idx)
+      new_content = expand_groups_in_content(type.content, groups_idx)
+
+      Schema::ComplexType.new(
+        name: type.name, anonymous: type.anonymous, base: type.base, derivation: type.derivation,
+        attributes: new_attributes, attribute_groups: [],
+        content: new_content, mixed: type.mixed, doc: type.doc
+      )
+    end
+
+    def ag_refs_to_attributes(refs, ag_idx)
+      refs.flat_map do |ref|
+        ag = ag_idx[[ref.ref.namespace, ref.ref.local_name]]
+        raise ResolveError.new("unresolved attributeGroup ref: #{ref.ref.local_name}", source: nil) unless ag
+
+        ag.attributes + ag_refs_to_attributes(ag.attribute_groups, ag_idx)
+      end
+    end
+
+    def expand_groups_in_content(content, groups_idx)
+      case content
+      when Schema::Sequence
+        Schema::Sequence.new(items: content.items.flat_map do |i|
+          expand_particle(i, groups_idx)
+        end, min_occurs: content.min_occurs, max_occurs: content.max_occurs)
+      when Schema::Choice
+        Schema::Choice.new(items: content.items.flat_map do |i|
+          expand_particle(i, groups_idx)
+        end, min_occurs: content.min_occurs, max_occurs: content.max_occurs)
+      else
+        content
+      end
+    end
+
+    def expand_particle(particle, groups_idx)
+      case particle
+      when Schema::GroupRef
+        g = groups_idx[[particle.ref.namespace, particle.ref.local_name]]
+        raise ResolveError.new("unresolved group ref: #{particle.ref.local_name}", source: nil) unless g
+
+        case g.content
+        when Schema::Sequence, Schema::Choice then g.content.items
+        else []
+        end
+      when Schema::Sequence, Schema::Choice
+        [expand_groups_in_content(particle, groups_idx)]
+      else
+        [particle]
+      end
+    end
+
+    def flatten_extension(type, all_types, ag_idx)
+      return type unless type.is_a?(Schema::ComplexType) && type.derivation == :extension && type.base
+
+      base = all_types.find { |t| t.is_a?(Schema::ComplexType) && t.name == type.base.local_name }
+      return type unless base # base is in another namespace or built-in (simpleContent extension)
+
+      base_flat = flatten_extension(base, all_types, ag_idx)
+      Schema::ComplexType.new(
+        name: type.name, anonymous: type.anonymous, base: type.base, derivation: type.derivation,
+        attributes: base_flat.attributes + type.attributes,
+        attribute_groups: type.attribute_groups,
+        content: merge_content(base_flat.content, type.content),
+        mixed: type.mixed,
+        doc: type.doc
+      )
+    end
+
+    def merge_content(base_content, derived_content)
+      return derived_content if base_content.nil?
+      return base_content if derived_content.nil?
+      if base_content.is_a?(Schema::Sequence) && derived_content.is_a?(Schema::Sequence)
+        return Schema::Sequence.new(items: base_content.items + derived_content.items, min_occurs: 1,
+                                    max_occurs: 1)
+      end
+
+      derived_content
+    end
+
+    def build_index
+      idx = {}
+      @doc.types.each { |t| idx[[@doc.target_namespace, t.name]] = t }
+      idx
+    end
+
+    # ----- Promotion -----
+
+    def promote_within(type, parent_name:)
+      case type
+      when Schema::ComplexType
+        new_attributes = type.attributes.map { |a| promote_in_attribute(a, parent_name: parent_name) }
+        new_content    = promote_in_content(type.content, parent_name: parent_name)
+        Schema::ComplexType.new(
+          name: type.name, anonymous: type.anonymous, base: type.base, derivation: type.derivation,
+          attributes: new_attributes, attribute_groups: type.attribute_groups,
+          content: new_content, mixed: type.mixed, doc: type.doc
+        )
+      else
+        type
+      end
+    end
+
+    def promote_in_element(elem, parent_name:)
+      if elem.inline_type
+        promoted_name = synthesize_name(parent_name)
+        promoted = rename(elem.inline_type, promoted_name)
+        promoted = promote_within(promoted, parent_name: promoted_name)
+        @promoted << promoted
+        Schema::Element.new(
+          name: elem.name,
+          type_ref: Schema::TypeRef.new(namespace: @target_ns, local_name: promoted_name),
+          inline_type: nil,
+          min_occurs: elem.min_occurs, max_occurs: elem.max_occurs,
+          nillable: elem.nillable, default: elem.default, fixed: elem.fixed, doc: elem.doc
+        )
+      else
+        elem
+      end
+    end
+
+    def promote_in_attribute(attr, parent_name:)
+      if attr.inline_type
+        promoted_name = synthesize_name(parent_name, "#{pascal_case(attr.name)}Attr")
+        promoted = rename(attr.inline_type, promoted_name)
+        promoted = promote_within(promoted, parent_name: promoted_name)
+        @promoted << promoted
+        Schema::Attribute.new(
+          name: attr.name,
+          type_ref: Schema::TypeRef.new(namespace: @target_ns, local_name: promoted_name),
+          inline_type: nil,
+          use: attr.use, default: attr.default, fixed: attr.fixed, doc: attr.doc
+        )
+      else
+        attr
+      end
+    end
+
+    def promote_in_content(content, parent_name:)
+      case content
+      when Schema::Sequence
+        Schema::Sequence.new(
+          items: content.items.map { |i| promote_in_particle(i, parent_name: parent_name) },
+          min_occurs: content.min_occurs, max_occurs: content.max_occurs
+        )
+      when Schema::Choice
+        Schema::Choice.new(
+          items: content.items.map { |i| promote_in_particle(i, parent_name: parent_name) },
+          min_occurs: content.min_occurs, max_occurs: content.max_occurs
+        )
+      else
+        content
+      end
+    end
+
+    def promote_in_particle(particle, parent_name:)
+      case particle
+      when Schema::Element
+        promote_in_element(particle, parent_name: "#{parent_name}_#{pascal_case(particle.name)}")
+      when Schema::Sequence, Schema::Choice
+        promote_in_content(particle, parent_name: parent_name)
+      else
+        particle
+      end
+    end
+
+    def rename(type, new_name)
+      case type
+      when Schema::ComplexType
+        Schema::ComplexType.new(
+          name: new_name, anonymous: false, base: type.base, derivation: type.derivation,
+          attributes: type.attributes, attribute_groups: type.attribute_groups,
+          content: type.content, mixed: type.mixed, doc: type.doc
+        )
+      when Schema::SimpleType
+        Schema::SimpleType.new(name: new_name, anonymous: false, body: type.body, doc: type.doc)
+      end
+    end
+
+    def synthesize_name(*parts)
+      base = parts.compact.map { |p| pascal_case(p) }.join("_")
+      candidate = base
+      counter = 1
+      while @existing_names.include?(candidate)
+        counter += 1
+        candidate = "#{base}_#{counter}"
+      end
+      @existing_names << candidate
+      candidate
+    end
+
+    def pascal_case(name)
+      return "" if name.nil?
+
+      name.to_s.gsub(/[^A-Za-z0-9]+/, "_").split("_").map { |s| s[0].to_s.upcase + s[1..].to_s }.join
+    end
+
+    # ----- Validation walk (TypeRef checks) -----
+
+    def check_all_type_refs
+      @doc.types.each    { |t| walk(t) }
+      @doc.elements.each { |e| walk_element(e) }
+    end
+
+    def walk(node)
+      case node
+      when Schema::ComplexType
+        check_ref(node.base) if node.base
+        node.attributes.each { |a| walk_attribute(a) }
+        walk_content(node.content) if node.content
+      when Schema::SimpleType
+        walk_simple_body(node.body) if node.body
+      end
+    end
+
+    def walk_content(node)
+      case node
+      when Schema::Sequence, Schema::Choice
+        node.items.each { |item| walk_particle(item) }
+      end
+    end
+
+    def walk_particle(node)
+      case node
+      when Schema::Element                  then walk_element(node)
+      when Schema::Sequence, Schema::Choice then walk_content(node)
+      when Schema::GroupRef, Schema::Any    then nil
+      end
+    end
+
+    def walk_element(elem)
+      check_ref(elem.type_ref) if elem.type_ref
+    end
+
+    def walk_attribute(attr)
+      check_ref(attr.type_ref) if attr.type_ref
+    end
+
+    def walk_simple_body(body)
+      case body
+      when Schema::Restriction then check_restriction(body)
+      when Schema::List        then check_list(body)
+      when Schema::Union       then check_union(body)
+      end
+    end
+
+    def check_restriction(body)
+      check_ref(body.base) if body.base
+    end
+
+    def check_list(body)
+      check_ref(body.item_type) if body.item_type.is_a?(Schema::TypeRef)
+    end
+
+    def check_union(body)
+      body.member_types.each { |member| check_ref(member) if member.is_a?(Schema::TypeRef) }
+    end
+
+    def check_ref(ref)
+      return if ref.nil?
+      return if BuiltinTypes.builtin?(ref.namespace, ref.local_name)
+      return if @types_by_qname.key?([ref.namespace, ref.local_name])
+
+      raise ResolveError.new("unresolved type reference: {#{ref.namespace}}#{ref.local_name}", source: nil)
+    end
+  end
+end

data/lib/schema_forge/schema.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  module Schema
+    Document = Data.define(
+      :target_namespace, :namespaces, :types, :elements,
+      :groups, :attribute_groups, :imports, :includes
+    )
+
+    ComplexType = Data.define(
+      :name, :anonymous, :base, :derivation,
+      :attributes, :attribute_groups, :content, :mixed, :doc
+    )
+
+    SimpleType = Data.define(:name, :anonymous, :body, :doc)
+
+    Element = Data.define(
+      :name, :type_ref, :inline_type,
+      :min_occurs, :max_occurs, :nillable, :default, :fixed, :doc
+    )
+
+    Attribute = Data.define(
+      :name, :type_ref, :inline_type, :use, :default, :fixed, :doc
+    )
+
+    Sequence = Data.define(:items, :min_occurs, :max_occurs)
+    Choice   = Data.define(:items, :min_occurs, :max_occurs)
+
+    Group             = Data.define(:name, :content)
+    GroupRef          = Data.define(:ref, :min_occurs, :max_occurs)
+    AttributeGroup    = Data.define(:name, :attributes, :attribute_groups)
+    AttributeGroupRef = Data.define(:ref)
+
+    Restriction = Data.define(:base, :facets)
+    Extension   = Data.define(:base, :content, :attributes, :attribute_groups)
+
+    List  = Data.define(:item_type)
+    Union = Data.define(:member_types)
+
+    TypeRef = Data.define(:namespace, :local_name)
+
+    Any = Data.define(:namespace, :process_contents, :min_occurs, :max_occurs)
+
+    Import  = Data.define(:namespace, :schema_location)
+    Include = Data.define(:schema_location)
+  end
+end

data/lib/schema_forge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  VERSION = "0.1.0"
+end

data/lib/schema_forge/writer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SchemaForge
+  module Writer
+    module_function
+
+    def write(output_dir, source_path, content)
+      FileUtils.mkdir_p(output_dir)
+      base = File.basename(source_path, ".*")
+      target = File.join(output_dir, "#{base}.rb")
+      File.write(target, content)
+      target
+    end
+  end
+end

data/lib/schema_forge.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "schema_forge/version"
+require_relative "schema_forge/errors"
+require_relative "schema_forge/builtin_types"
+require_relative "schema_forge/schema"
+require_relative "schema_forge/parser"
+require_relative "schema_forge/loader"
+require_relative "schema_forge/resolver"
+require_relative "schema_forge/naming"
+require_relative "schema_forge/hooks"
+require_relative "schema_forge/generator"
+require_relative "schema_forge/writer"
+
+module SchemaForge
+  module_function
+
+  def generate(input:, output:, module_name: "Schema", hooks: nil, fetch_remote: true)
+    each_xsd(input) do |path|
+      source = generate_one(path, module_name: module_name, hooks: hooks, fetch_remote: fetch_remote)
+      Writer.write(output, path, source)
+    end
+  end
+
+  def generate_string(input:, module_name: "Schema", hooks: nil, fetch_remote: true)
+    paths = enumerate_xsd(input)
+    raise ArgumentError, "generate_string requires a single XSD file, got: #{input}" if paths.size != 1
+
+    generate_one(paths.first, module_name: module_name, hooks: hooks, fetch_remote: fetch_remote)
+  end
+
+  def each_xsd(input, &)
+    enumerate_xsd(input).each(&)
+  end
+
+  def enumerate_xsd(input)
+    if File.directory?(input)
+      Dir[File.join(input, "*.xsd")]
+    else
+      [input]
+    end
+  end
+
+  def generate_one(path, module_name:, hooks:, fetch_remote:)
+    doc = Loader.load(path, fetch_remote: fetch_remote)
+    resolved = Resolver.resolve(doc)
+    Generator.new(module_name: module_name, hooks: hooks).emit(resolved)
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: schemaforge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- igbanam
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description: Parses XSD files and emits Ruby Data.define value objects with runtime
+  validation.
+email:
+- xigbanam@gmail.com
+executables:
+- schemaforge
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/schemaforge
+- lib/schema_forge.rb
+- lib/schema_forge/builtin_types.rb
+- lib/schema_forge/errors.rb
+- lib/schema_forge/generator.rb
+- lib/schema_forge/hooks.rb
+- lib/schema_forge/loader.rb
+- lib/schema_forge/naming.rb
+- lib/schema_forge/parser.rb
+- lib/schema_forge/resolver.rb
+- lib/schema_forge/schema.rb
+- lib/schema_forge/version.rb
+- lib/schema_forge/writer.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+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: 4.0.10
+specification_version: 4
+summary: Generate Ruby Data.define value objects from XSD schemas.
+test_files: []