schemaforge 0.1.0

data/lib/schema_forge/loader.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "uri"
+require "net/http"
+
+module SchemaForge
+  class Loader
+    Accumulators = Struct.new(:types, :elements, :groups, :attribute_groups)
+
+    def self.load(path_or_uri, fetch_remote: true)
+      new(fetch_remote: fetch_remote).load(path_or_uri)
+    end
+
+    def initialize(fetch_remote: true)
+      @fetch_remote = fetch_remote
+      @visited = {}
+    end
+
+    def load(path_or_uri)
+      doc = load_one(path_or_uri)
+      merge_includes(doc, base_for(path_or_uri))
+    end
+
+    private
+
+    def load_one(path_or_uri)
+      key = canonicalize(path_or_uri)
+      return nil if @visited.key?(key)
+
+      @visited[key] = true
+      source = read(path_or_uri)
+      Parser.parse(source, base_path: path_or_uri.to_s)
+    end
+
+    def merge_includes(doc, base)
+      return doc if doc.nil?
+
+      acc = Accumulators.new(
+        doc.types.dup,
+        doc.elements.dup,
+        doc.groups.dup,
+        doc.attribute_groups.dup
+      )
+
+      apply_includes(doc.includes, base, acc)
+      apply_imports(doc.imports, base, acc)
+
+      Schema::Document.new(
+        target_namespace: doc.target_namespace,
+        namespaces: doc.namespaces,
+        types: acc.types,
+        elements: acc.elements,
+        groups: acc.groups,
+        attribute_groups: acc.attribute_groups,
+        imports: doc.imports.dup,
+        includes: []
+      )
+    end
+
+    def apply_includes(includes, base, acc)
+      includes.each do |inc|
+        inc_path = resolve(base, inc.schema_location)
+        included = load_one(inc_path)
+        next if included.nil?
+
+        included = merge_includes(included, base_for(inc_path))
+        acc.types.concat(included.types)
+        acc.elements.concat(included.elements)
+        acc.groups.concat(included.groups)
+        acc.attribute_groups.concat(included.attribute_groups)
+      end
+    end
+
+    def apply_imports(imports, base, acc)
+      imports.each do |imp|
+        next if imp.schema_location.nil? || imp.schema_location.empty?
+
+        imp_path = resolve(base, imp.schema_location)
+        imported = load_one(imp_path)
+        next if imported.nil?
+
+        imported = merge_includes(imported, base_for(imp_path))
+        acc.types.concat(imported.types)
+        acc.elements.concat(imported.elements)
+        acc.groups.concat(imported.groups)
+        acc.attribute_groups.concat(imported.attribute_groups)
+      end
+    end
+
+    def read(path_or_uri)
+      if remote?(path_or_uri)
+        raise FetchError.new("remote fetch disabled for #{path_or_uri}", source: path_or_uri.to_s) unless @fetch_remote
+
+        fetch_remote(path_or_uri)
+      else
+        File.read(path_or_uri)
+      end
+    end
+
+    def fetch_remote(uri)
+      uri = URI(uri)
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", read_timeout: 30) do |http|
+        http.get(uri.request_uri)
+      end
+      raise FetchError.new("HTTP #{response.code} for #{uri}", source: uri.to_s) unless response.is_a?(Net::HTTPSuccess)
+
+      response.body
+    end
+
+    def remote?(loc)
+      loc.to_s.match?(%r{\Ahttps?://})
+    end
+
+    def base_for(path_or_uri)
+      remote?(path_or_uri) ? URI(path_or_uri) : File.dirname(File.expand_path(path_or_uri))
+    end
+
+    def resolve(base, location)
+      return location if remote?(location)
+
+      if base.is_a?(URI)
+        URI.join(base.to_s, location).to_s
+      else
+        File.expand_path(location, base)
+      end
+    end
+
+    def canonicalize(loc)
+      remote?(loc) ? URI(loc).to_s : File.expand_path(loc)
+    end
+  end
+end

data/lib/schema_forge/naming.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SchemaForge
+  module Naming
+    RUBY_KEYWORDS = %w[
+      BEGIN END alias and begin break case class def defined? do else elsif end
+      ensure false for if in module next nil not or redo rescue retry return self
+      super then true undef unless until when while yield
+    ].freeze
+
+    module_function
+
+    def pascal_case(name)
+      keyword = RUBY_KEYWORDS.include?(name.to_s)
+      base = name.to_s.split(/[^A-Za-z0-9]/).reject(&:empty?).map { |s| s[0].to_s.upcase + s[1..].to_s }.join
+      base = "_" if base.empty?
+      keyword ? "#{base}_" : base
+    end
+
+    def snake_case(name)
+      s = name.to_s
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .tr("-", "_")
+              .downcase
+      append_underscore_if_keyword(s)
+    end
+
+    def attr_field(name)
+      "#{snake_case(name).chomp('_')}_attr"
+    end
+
+    def append_underscore_if_keyword(name)
+      RUBY_KEYWORDS.include?(name) ? "#{name}_" : name
+    end
+  end
+end

data/lib/schema_forge/parser.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module SchemaForge
+  class Parser
+    XSD_NS = "http://www.w3.org/2001/XMLSchema"
+
+    NUMERIC_FACETS = %w[length minLength maxLength totalDigits fractionDigits].freeze
+    VALUE_FACETS   = %w[minInclusive maxInclusive minExclusive maxExclusive whiteSpace pattern].freeze
+
+    FACET_KEY = {
+      "length" => :length,
+      "minLength" => :min_length,
+      "maxLength" => :max_length,
+      "totalDigits" => :total_digits,
+      "fractionDigits" => :fraction_digits,
+      "minInclusive" => :min_inclusive,
+      "maxInclusive" => :max_inclusive,
+      "minExclusive" => :min_exclusive,
+      "maxExclusive" => :max_exclusive,
+      "whiteSpace" => :white_space,
+      "pattern" => :pattern,
+      "enumeration" => :enumeration
+    }.freeze
+
+    def self.parse(source, base_path:)
+      new(source, base_path: base_path).parse
+    end
+
+    def initialize(source, base_path:)
+      @source = source
+      @base_path = base_path
+    end
+
+    def parse
+      doc = Nokogiri::XML(@source, &:strict)
+      schema_node = doc.root
+      unless schema_node && schema_node.name == "schema"
+        raise ParseError.new("missing <schema> root", source: @base_path)
+      end
+
+      @namespaces = build_namespaces(schema_node)
+      @target_namespace = schema_node["targetNamespace"]
+
+      types           = collect_types(schema_node)
+      groups          = collect_groups(schema_node)
+      attribute_groups = collect_attribute_groups(schema_node)
+
+      Schema::Document.new(
+        target_namespace: @target_namespace,
+        namespaces: @namespaces,
+        types: types,
+        elements: collect_elements(schema_node),
+        groups: groups,
+        attribute_groups: attribute_groups,
+        imports: collect_imports(schema_node),
+        includes: collect_includes(schema_node)
+      )
+    rescue Nokogiri::XML::SyntaxError => e
+      raise ParseError.new(e.message, source: @base_path)
+    end
+
+    private
+
+    def build_namespaces(node)
+      node.namespaces.transform_keys { |k| k.sub(/\Axmlns:?/, "") }
+    end
+
+    def collect_types(schema_node)
+      simple  = schema_node.xpath("./xs:simpleType",  "xs" => XSD_NS).map { |n| parse_simple_type(n, anonymous: false) }
+      complex = schema_node.xpath("./xs:complexType", "xs" => XSD_NS).map do |n|
+        parse_complex_type(n, anonymous: false)
+      end
+      simple + complex
+    end
+
+    def collect_groups(schema_node)
+      schema_node.xpath("./xs:group", "xs" => XSD_NS).map do |n|
+        Schema::Group.new(name: n["name"], content: parse_content_model(n))
+      end
+    end
+
+    def collect_elements(schema_node)
+      schema_node.xpath("./xs:element", "xs" => XSD_NS).map { |n| parse_element(n) }
+    end
+
+    def collect_includes(schema_node)
+      schema_node.xpath("./xs:include", "xs" => XSD_NS).map do |n|
+        Schema::Include.new(schema_location: n["schemaLocation"])
+      end
+    end
+
+    def collect_imports(schema_node)
+      schema_node.xpath("./xs:import", "xs" => XSD_NS).map do |n|
+        Schema::Import.new(namespace: n["namespace"], schema_location: n["schemaLocation"])
+      end
+    end
+
+    def collect_attribute_groups(schema_node)
+      schema_node.xpath("./xs:attributeGroup", "xs" => XSD_NS).map do |n|
+        Schema::AttributeGroup.new(
+          name: n["name"],
+          attributes: n.xpath("./xs:attribute", "xs" => XSD_NS).map { |a| parse_attribute(a) },
+          attribute_groups: collect_attribute_group_refs(n)
+        )
+      end
+    end
+
+    def collect_attribute_group_refs(node)
+      node.xpath("./xs:attributeGroup[@ref]", "xs" => XSD_NS).map do |r|
+        Schema::AttributeGroupRef.new(ref: parse_type_ref(r["ref"]))
+      end
+    end
+
+    def parse_simple_type(node, anonymous:)
+      body =
+        if (r = node.at_xpath("./xs:restriction", "xs" => XSD_NS))
+          parse_restriction(r)
+        elsif (l = node.at_xpath("./xs:list", "xs" => XSD_NS))
+          parse_list(l)
+        elsif (u = node.at_xpath("./xs:union", "xs" => XSD_NS))
+          parse_union(u)
+        end
+
+      Schema::SimpleType.new(
+        name: node["name"],
+        anonymous: anonymous,
+        body: body,
+        doc: parse_annotation(node)
+      )
+    end
+
+    def parse_restriction(node)
+      facets = {}
+      node.element_children.each do |child|
+        next unless child.namespace && child.namespace.href == XSD_NS
+
+        accumulate_facet(facets, child)
+      end
+      Schema::Restriction.new(base: parse_type_ref(node["base"]), facets: facets)
+    end
+
+    def accumulate_facet(facets, child)
+      case child.name
+      when "enumeration"
+        (facets[:enumeration] ||= []) << child["value"]
+      when *NUMERIC_FACETS
+        facets[FACET_KEY[child.name]] = Integer(child["value"])
+      when *VALUE_FACETS
+        v = child["value"]
+        facets[FACET_KEY[child.name]] = numeric_facet?(child.name) ? Float(v) : v
+      end
+    end
+
+    def numeric_facet?(name)
+      %w[minInclusive maxInclusive minExclusive maxExclusive].include?(name)
+    end
+
+    def parse_list(node)
+      Schema::List.new(item_type: parse_type_ref(node["itemType"]))
+    end
+
+    def parse_union(node)
+      members = (node["memberTypes"] || "").split(/\s+/).reject(&:empty?).map { |s| parse_type_ref(s) }
+      Schema::Union.new(member_types: members)
+    end
+
+    def parse_complex_type(node, anonymous:)
+      derivation, base, attributes, attribute_groups, content = resolve_complex_type_body(node)
+
+      Schema::ComplexType.new(
+        name: node["name"],
+        anonymous: anonymous,
+        base: base,
+        derivation: derivation,
+        attributes: attributes,
+        attribute_groups: attribute_groups,
+        content: content,
+        mixed: node["mixed"] == "true",
+        doc: parse_annotation(node)
+      )
+    end
+
+    def resolve_complex_type_body(node)
+      if (sc = node.at_xpath("./xs:simpleContent", "xs" => XSD_NS))
+        parse_simple_content(sc)
+      elsif (cc = node.at_xpath("./xs:complexContent", "xs" => XSD_NS))
+        parse_complex_content(cc)
+      else
+        attrs = node.xpath("./xs:attribute", "xs" => XSD_NS).map { |a| parse_attribute(a) }
+        [nil, nil, attrs, collect_attribute_group_refs(node), parse_content_model(node)]
+      end
+    end
+
+    def parse_simple_content(node)
+      ext = node.at_xpath("./xs:extension", "xs" => XSD_NS)
+      raise ParseError.new("simpleContent without extension not yet supported", source: @base_path) unless ext
+
+      attrs = ext.xpath("./xs:attribute", "xs" => XSD_NS).map { |a| parse_attribute(a) }
+      [:extension, parse_type_ref(ext["base"]), attrs, collect_attribute_group_refs(ext), nil]
+    end
+
+    def parse_complex_content(node)
+      ext = node.at_xpath("./xs:extension", "xs" => XSD_NS)
+      raise ParseError.new("complexContent without extension not yet supported", source: @base_path) unless ext
+
+      attrs = ext.xpath("./xs:attribute", "xs" => XSD_NS).map { |a| parse_attribute(a) }
+      [:extension, parse_type_ref(ext["base"]), attrs, collect_attribute_group_refs(ext), parse_content_model(ext)]
+    end
+
+    def parse_content_model(node)
+      seq = node.at_xpath("./xs:sequence", "xs" => XSD_NS)
+      return parse_sequence(seq) if seq
+
+      ch = node.at_xpath("./xs:choice", "xs" => XSD_NS)
+      return parse_choice(ch) if ch
+
+      nil
+    end
+
+    def parse_sequence(node)
+      Schema::Sequence.new(
+        items: parse_particles(node),
+        min_occurs: occurs(node["minOccurs"], 1),
+        max_occurs: occurs(node["maxOccurs"], 1)
+      )
+    end
+
+    def parse_choice(node)
+      Schema::Choice.new(
+        items: parse_particles(node),
+        min_occurs: occurs(node["minOccurs"], 1),
+        max_occurs: occurs(node["maxOccurs"], 1)
+      )
+    end
+
+    def parse_particles(parent)
+      particles = []
+      parent.element_children.each do |child|
+        next unless child.namespace && child.namespace.href == XSD_NS
+
+        particle = parse_particle(child)
+        particles << particle if particle
+      end
+      particles
+    end
+
+    def parse_particle(child)
+      case child.name
+      when "element"  then parse_element(child)
+      when "sequence" then parse_sequence(child)
+      when "choice"   then parse_choice(child)
+      when "group"    then parse_group_particle(child)
+      when "any"
+        Schema::Any.new(
+          namespace: child["namespace"],
+          process_contents: child["processContents"],
+          min_occurs: occurs(child["minOccurs"], 1),
+          max_occurs: occurs(child["maxOccurs"], 1)
+        )
+      end
+    end
+
+    def parse_group_particle(node)
+      return unless node["ref"]
+
+      Schema::GroupRef.new(
+        ref: parse_type_ref(node["ref"]),
+        min_occurs: occurs(node["minOccurs"], 1),
+        max_occurs: occurs(node["maxOccurs"], 1)
+      )
+    end
+
+    def parse_element(node)
+      inline_type = nil
+      if (ct = node.at_xpath("./xs:complexType", "xs" => XSD_NS))
+        inline_type = parse_complex_type(ct, anonymous: true)
+      elsif (st = node.at_xpath("./xs:simpleType", "xs" => XSD_NS))
+        inline_type = parse_simple_type(st, anonymous: true)
+      end
+
+      Schema::Element.new(
+        name: node["name"],
+        type_ref: parse_type_ref(node["type"]),
+        inline_type: inline_type,
+        min_occurs: occurs(node["minOccurs"], 1),
+        max_occurs: occurs(node["maxOccurs"], 1),
+        nillable: node["nillable"] == "true",
+        default: node["default"],
+        fixed: node["fixed"],
+        doc: parse_annotation(node)
+      )
+    end
+
+    def parse_attribute(node)
+      use = node["use"]&.to_sym || :optional
+      inline_type = nil
+      if (st = node.at_xpath("./xs:simpleType", "xs" => XSD_NS))
+        inline_type = parse_simple_type(st, anonymous: true)
+      end
+
+      Schema::Attribute.new(
+        name: node["name"],
+        type_ref: parse_type_ref(node["type"]),
+        inline_type: inline_type,
+        use: use,
+        default: node["default"],
+        fixed: node["fixed"],
+        doc: parse_annotation(node)
+      )
+    end
+
+    def parse_annotation(node)
+      ann = node.at_xpath("./xs:annotation", "xs" => XSD_NS)
+      return nil unless ann
+
+      doc = ann.at_xpath("./xs:documentation", "xs" => XSD_NS)
+      app = ann.at_xpath("./xs:appinfo", "xs" => XSD_NS)
+      result = {}
+      result[:documentation] = doc.content.strip if doc
+      result[:appinfo]       = app.content.strip if app
+      result.empty? ? nil : result
+    end
+
+    def occurs(value, default)
+      return default if value.nil? || value.empty?
+      return :unbounded if value == "unbounded"
+
+      Integer(value)
+    end
+
+    def parse_type_ref(qname)
+      return nil if qname.nil? || qname.empty?
+
+      if qname.include?(":")
+        prefix, local = qname.split(":", 2)
+        Schema::TypeRef.new(namespace: @namespaces[prefix], local_name: local)
+      else
+        ns = @namespaces[""] == XSD_NS ? XSD_NS : @target_namespace
+        ns = XSD_NS if BuiltinTypes.builtin?(XSD_NS, qname)
+        Schema::TypeRef.new(namespace: ns, local_name: qname)
+      end
+    end
+  end
+end