xsd 2.7.10 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a878430d5f353e97e8051c23a339f05c87949d9f385fb538a555a68f43658698
-  data.tar.gz: 1f46317798a47375938d185acb9a908f517e0078f5669d39c28c8120c09d4cd5
+  metadata.gz: 40e6cbfb1356c6d21529ad7339f3ada85dbf85be27d7d0fcd3ecd59e55250192
+  data.tar.gz: 544ea96a3cc35ac6a37f8ab8971ae7d30c1b4a89c11c80ae6475ad1fcc61a6ae
 SHA512:
-  metadata.gz: 56465f9472a9373a2c87a38125bb9426a27ed7bcec3757bc98b5ed9dc93cf44b88753f628769e800838c6ef527ea131a2f4b3deaab3c898a59db46ea5cd7a3df
-  data.tar.gz: e6cd2ade397762b2ff9661de36bf7d5c8e0a7e488b49e408019e9e4dca6c6bb0416b459e16890e1d1980aadef02a590ae0d0cf530a869e8ed4b8c9b4c223579f
+  metadata.gz: 6fbc961bab3eac175a05dd99a8cbb34dce5384f682def039f708407f281cbbbe75f5ec6a57a751fff2c8fbad927fd83edf2b1e8e488f255655777a0ce7cf36d0
+  data.tar.gz: 4f8c2fa9687ed1f4647e91884abd60d63be92fcbda2475cc3b0aa3b340f9ca6ae7fbe12d91343389de1cd0616a676c45e018e88e8dcbe557d7014ce24c02d227

data/.rubocop.yml

@@ -23,9 +23,6 @@ Layout/HashAlignment:
 Layout/LineLength:
   Enabled: false
 
-Lint/HashCompareByIdentity:
-  Enabled: false
-
 Layout/SpaceAroundOperators:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## [2.8.0] - 2026-09-21
+
+### Fixed
+
+- `XSD::XML.open` resolves relative import/include locations against the schema they were read from, so the default
+  resource resolver no longer requires a custom one for ordinary multi-file schemas
+- `Schema#validate` writes included schemas into the temporary directory too, so schemas wired together with
+  `<xs:include>` can be validated
+- `Schema#validate` serializes the temporary schemas as UTF-8, so schemas in another encoding no longer fail to load
+- `XML#logger` no longer raises `NameError` when no logger is configured (`logger` was never required)
+- `BaseObject#parent` returns `nil` instead of raising when the parent node has no XSD object (document, `wsdl:types`)
+- `object_by_name` passes the searched name as an xpath variable instead of interpolating it into the expression
+- `ComplexType#mixed_content?` and `#data_type` no longer raise on a `complexContent`/`simpleContent` without a
+  derivation
+- An `<xs:include>` of a schema without a target namespace ("chameleon" include) is accepted
+- Import/include cycles no longer yield duplicated definitions
+- The compiled validator no longer leaks an open file descriptor
+- `Element#attributes?` and `ComplexType#complex_content?` return booleans instead of the underlying objects
+- Import/include error messages name the namespaces that did not match
+- `require 'xsd'` defines `XSD::VERSION`, which previously needed `require 'xsd/version'` on top of it
+
+### Changed
+
+- Imported/included schemas are loaded once per location and shared, instead of being re-read and re-parsed for every
+  reference to them
+- Property, link and child lookups cache `nil` and `false` results, which cuts repeated xpath searches (roughly 2.5x
+  faster traversal of the bundled example schemas)
+- `XSD::XML#add_schema_xml`/`#add_schema_node` accept a `location:` keyword, and `Schema#location` exposes it
+- `XML#object_cache` is keyed by node identity (`Hash#compare_by_identity`) rather than by `node.object_id`, which
+  lets the `Lint/HashCompareByIdentity` rule be enabled again
+
 ## [2.7.10] - 2024-04-26
 
 - Fix data_type detection in complex_type simple_content extension

data/lib/xsd/base_object.rb

@@ -16,6 +16,9 @@ module XSD
     # Base XMLSchema namespace
     XML_SCHEMA = 'http://www.w3.org/2001/XMLSchema'
 
+    # Namespace map used for all internal xpath queries
+    XML_SCHEMA_NS = { 'xs' => XML_SCHEMA }.freeze
+
     class << self
       attr_reader :properties, :children, :links
 
@@ -33,10 +36,10 @@ module XSD
     end
 
     def initialize(options = {})
-      @options = options
-      @cache = {}
+      raise Error, "#{self.class}.new expects a hash parameter" unless options.is_a?(Hash)
 
-      raise Error, "#{self.class}.new expects a hash parameter" unless @options.is_a?(Hash)
+      @options = options
+      @cache   = {}
     end
 
     # Get current XML node
@@ -67,9 +70,10 @@ module XSD
 
     # Get child nodes
     # @param [Symbol] name
+    # @param [Boolean] deep
     # @return Nokogiri::XML::NodeSet
     def nodes(name = :*, deep = false)
-      node.xpath("./#{deep ? '/' : ''}xs:#{name}", { 'xs' => XML_SCHEMA })
+      node.xpath("./#{deep ? '/' : ''}xs:#{name}", XML_SCHEMA_NS)
     end
 
     # Get schemas by namespace or prefix
@@ -77,7 +81,7 @@ module XSD
     # @return Array<Schema>
     def schemas_for_namespace(ns_or_prefix)
       # resolve namespace for current node if prefix was provided
-      prefix = node.namespaces[['xmlns', (ns_or_prefix == '' ? nil : ns_or_prefix)].compact.join(':')]
+      prefix = namespaces[['xmlns', (ns_or_prefix == '' ? nil : ns_or_prefix)].compact.join(':')]
       ns = prefix || ns_or_prefix
 
       if schema.targets_namespace?(ns)
@@ -116,7 +120,7 @@ module XSD
     def object_by_name(node_name, name)
       # get prefix and local name
       name_prefix = get_prefix(name)
-      name_local = strip_prefix(name)
+      name_local  = strip_prefix(name)
 
       # do not search for built-in types
       return nil if schema.namespace_prefix == name_prefix
@@ -124,9 +128,9 @@ module XSD
       # determine schema for namespace
       search_schemas = schemas_for_namespace(name_prefix)
 
-      # find element in target schema
+      # find element in target schema, name is passed as an xpath variable to stay safe with any name contents
       search_schemas.each do |s|
-        node = s.node.at_xpath("./xs:#{node_name}[@name=\"#{name_local}\"]", { 'xs' => XML_SCHEMA })
+        node = s.node.at_xpath("./xs:#{node_name}[@name=$name]", XML_SCHEMA_NS, name: name_local)
         return s.node_to_object(node) if node
       end
 
@@ -134,22 +138,30 @@ module XSD
     end
 
     # Get reader object for node
-    # @param [Nokogiri::XML::Node]
+    # @param [Nokogiri::XML::Node] node
     # @return BaseObject
     def node_to_object(node)
       # check object in cache first
-      return reader.object_cache[node.object_id] if reader.object_cache[node.object_id]
+      cached = reader.object_cache[node]
+      return cached if cached
 
       klass = XML::CLASS_MAP[node.name]
       raise Error, "Object class not found for '#{node.name}'" unless klass
 
-      reader.object_cache[node.object_id] = klass.new(options.merge(node: node, schema: schema))
+      reader.object_cache[node] = klass.new(options.merge(node: node, schema: schema))
     end
 
     # Get xml parent object
     # @return BaseObject, nil
     def parent
-      node.respond_to?(:parent) && node.parent ? node_to_object(node.parent) : nil
+      return @parent if defined?(@parent)
+
+      parent_node = node.respond_to?(:parent) ? node.parent : nil
+
+      # the parent may be a document or a node of a foreign schema (e.g. wsdl:types), there is no object for those
+      @parent = if parent_node.is_a?(Nokogiri::XML::Element) && XML::CLASS_MAP.key?(parent_node.name)
+                  node_to_object(parent_node)
+                end
     end
 
     # Get current schema object
@@ -205,55 +217,47 @@ module XSD
     # @param [Nokogiri::XML::Node] node
     # @return Array<String>
     def documentation_for(node)
-      node.xpath('./xs:annotation/xs:documentation/text()', { 'xs' => XML_SCHEMA }).map { |x| x.text.strip }
+      node.xpath('./xs:annotation/xs:documentation/text()', XML_SCHEMA_NS).map { |x| x.text.strip }
     end
 
     # Get all available elements on the current stack level
     # @return Array<Element>
     def collect_elements(*)
-      return @collect_elements if @collect_elements
-
-      r = if NO_ELEMENTS_CONTAINER.include?(self.class.mapped_name)
-            []
-          elsif is_a?(Referenced) && ref
-            reference.collect_elements
-          else
-            # map children recursive
-            map_children(:*).map do |obj|
-              if obj.is_a?(Element) || obj.is_a?(Any)
-                obj
-              else
-                # get elements considering references
-                (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).collect_elements
-              end
-            end.flatten
-          end
-
-      @collect_elements = r
+      @collect_elements ||= if NO_ELEMENTS_CONTAINER.include?(self.class.mapped_name)
+                              []
+                            elsif is_a?(Referenced) && ref
+                              reference.collect_elements
+                            else
+                              # map children recursive
+                              map_children(:*).flat_map do |obj|
+                                if obj.is_a?(Element) || obj.is_a?(Any)
+                                  obj
+                                else
+                                  # get elements considering references
+                                  (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).collect_elements
+                                end
+                              end
+                            end
     end
 
     # Get all available attributes on the current stack level
     # @return Array<Attribute>
     def collect_attributes(*)
-      return @collect_attributes if @collect_attributes
-
-      r = if NO_ATTRIBUTES_CONTAINER.include?(self.class.mapped_name)
-            []
-          elsif is_a?(Referenced) && ref
-            reference.collect_attributes
-          else
-            # map children recursive
-            map_children(:*).map do |obj|
-              if obj.is_a?(Attribute) || obj.is_a?(AnyAttribute)
-                obj
-              else
-                # get attributes considering references
-                (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).collect_attributes
-              end
-            end.flatten
-          end
-
-      @collect_attributes = r
+      @collect_attributes ||= if NO_ATTRIBUTES_CONTAINER.include?(self.class.mapped_name)
+                                []
+                              elsif is_a?(Referenced) && ref
+                                reference.collect_attributes
+                              else
+                                # map children recursive
+                                map_children(:*).flat_map do |obj|
+                                  if obj.is_a?(Attribute) || obj.is_a?(AnyAttribute)
+                                    obj
+                                  else
+                                    # get attributes considering references
+                                    (obj.is_a?(Referenced) && obj.ref ? obj.reference : obj).collect_attributes
+                                  end
+                                end
+                              end
     end
 
     # Get reader instance
@@ -307,35 +311,17 @@ module XSD
     # @param [Symbol] method
     # @param [Array] args
     def method_missing(method, *args)
-      # check cache first
-      return @cache[method] if @cache[method]
+      # check cache first, nil and false results are cached as well
+      return @cache[method] if @cache.key?(method)
 
       # check for property first
       if (property = self.class.properties[method])
-        value = property[:resolve] ? property[:resolve].call(self) : node[property[:name].to_s]
-        r = if value.nil?
-              if node['ref']
-                # if object has reference - search property in referenced object
-                reference.send(method, *args)
-              else
-                property[:default].is_a?(Proc) ? instance_eval(&property[:default]) : property[:default]
-              end
-            else
-              case property[:type]
-              when :integer
-                property[:name] == :maxOccurs && value == 'unbounded' ? :unbounded : value.to_i
-              when :boolean
-                value == 'true'
-              else
-                value
-              end
-            end
-        return @cache[method] = r
+        return @cache[method] = property_value(property, method, args)
       end
 
       # if object has ref it cannot contain any type and children, so proxy call to target object
       if node['ref'] && method != :ref && method != :reference
-        return reference.send(method, *args)
+        return @cache[method] = reference.send(method, *args)
       end
 
       # then check for linked types
@@ -345,7 +331,7 @@ module XSD
           return @cache[method] = object_by_name(link[:type], name)
         elsif is_a?(Restriction) && %i[base_simple_type base_complex_type].include?(method)
           # handle restriction without base
-          return nil
+          return @cache[method] = nil
         end
       end
 
@@ -356,26 +342,24 @@ module XSD
       end
 
       super
-      # api = self.class.properties.keys + self.class.links.keys + self.class.children.keys
-      # raise Error, "Tried to access unknown object '#{method}' on '#{self.class.name}'. Available options are: #{api}"
     end
 
     # Does object has property/link/child?
     # @param [Symbol] method
-    # @param [Array] args
-    def respond_to_missing?(method, *args)
-      self.class.properties[method] || self.class.links[method] || self.class.children[method] || super
+    # @param [Boolean] include_private
+    def respond_to_missing?(method, include_private = false)
+      !self.class.properties[method].nil? || !self.class.links[method].nil? ||
+        !self.class.children[method].nil? || super
     end
 
     # Get mapped element name
     # @return Symbol
     def self.mapped_name
-      # @mapped_name ||= XML::CLASS_MAP.each { |k, v| return k.to_sym if v == self }
       @mapped_name ||= begin
-                         name = self.name.split('::').last
-                         name[0] = name[0].downcase
-                         name.to_sym
-                       end
+        name = self.name.split('::').last
+        name[0] = name[0].downcase
+        name.to_sym
+      end
     end
 
     # Return string if it is not empty, or nil otherwise
@@ -387,6 +371,34 @@ module XSD
 
     private
 
+    # Resolve property value from the node attribute, resolver block, reference or default
+    # @param [Hash] property
+    # @param [Symbol] method
+    # @param [Array] args
+    def property_value(property, method, args)
+      value = property[:resolve] ? property[:resolve].call(self) : node[property[:name].to_s]
+      return cast_property_value(property, value) unless value.nil?
+
+      # if object has reference - search property in referenced object
+      return reference.send(method, *args) if node['ref']
+
+      property[:default].is_a?(Proc) ? instance_eval(&property[:default]) : property[:default]
+    end
+
+    # Cast raw attribute value to the declared property type
+    # @param [Hash] property
+    # @param [String] value
+    def cast_property_value(property, value)
+      case property[:type]
+      when :integer
+        property[:name] == :maxOccurs && value == 'unbounded' ? :unbounded : value.to_i
+      when :boolean
+        value == 'true'
+      else
+        value
+      end
+    end
+
     def definition_match?(definition, query)
       # namespace included in query
       if query.start_with?('{')
@@ -395,7 +407,7 @@ module XSD
 
         namespace, name = parts
 
-        return false if namespace != definition.namespace
+        return false if nil_if_empty(namespace) != definition.namespace
       else
         name = query
       end

data/lib/xsd/objects/complex_type.rb

@@ -88,7 +88,9 @@ module XSD
       if complex_content
         return true if complex_content.mixed
 
-        return (complex_content.extension || complex_content.restriction).base_complex_type&.mixed_content?
+        derivation = complex_content.extension || complex_content.restriction
+
+        return derivation&.base_complex_type&.mixed_content? || false
       end
 
       false
@@ -102,7 +104,7 @@ module XSD
       elsif complex_content
         true
       else
-        group || all || choice || sequence
+        !!(group || all || choice || sequence)
       end
     end
 
@@ -118,28 +120,23 @@ module XSD
       return nil unless simple_content
 
       restriction = simple_content.restriction
-      if restriction
-        if restriction.base
-          if restriction.base_simple_type
-            restriction.base_simple_type.data_type
-          elsif restriction.base_complex_type
-            restriction.base_complex_type.data_type
-          else
-            strip_prefix(restriction.base)
-          end
-        else
-          restriction.simple_type&.data_type
-        end
-      else
-        extension = simple_content.extension
-        if extension.base_simple_type
-          extension.base_simple_type.data_type
-        elsif extension.base_complex_type
-          extension.base_complex_type.data_type
-        else
-          strip_prefix(extension.base)
-        end
-      end
+      return base_data_type(simple_content.extension) unless restriction
+      return restriction.simple_type&.data_type unless restriction.base
+
+      base_data_type(restriction)
+    end
+
+    private
+
+    # Get data type of an extension/restriction base type
+    # @param [Extension, Restriction, nil] derivation
+    # @return String, nil
+    def base_data_type(derivation)
+      return nil if derivation.nil?
+
+      derivation.base_simple_type&.data_type ||
+        derivation.base_complex_type&.data_type ||
+        strip_prefix(derivation.base)
     end
   end
 end

data/lib/xsd/objects/element.rb

@@ -121,7 +121,7 @@ module XSD
     # Determine if element has attributes
     # @return Boolean
     def attributes?
-      complex_type && collect_attributes.any?
+      !!complex_type && collect_attributes.any?
     end
 
     # Determine if element has mixed content
@@ -133,17 +133,16 @@ module XSD
     # Get substitutable elements
     # @return Array<Element>
     def substitutable_elements
-      @substitutable_elements ||= begin
-                                    if ref
-                                      reference.substitutable_elements
-                                    elsif !global? || %w[#all substitution].include?(block)
-                                      []
-                                    else
-                                      # TODO: we search substituted element only in the same schema with head element, is this enough?
-                                      # TODO: maybe don't collect all elements but search with xpath first?
-                                      schema.collect_elements.select do |element|
-                                        strip_prefix(element.substitution_group) == name
-                                      end
+      @substitutable_elements ||= if ref
+                                    reference.substitutable_elements
+                                  elsif !global? || %w[#all substitution].include?(block)
+                                    []
+                                  else
+                                    # TODO: we search substituted element only in the same schema with head element,
+                                    # is this enough?
+                                    # TODO: maybe don't collect all elements but search with xpath first?
+                                    schema.collect_elements.select do |element|
+                                      strip_prefix(element.substitution_group) == name
                                     end
                                   end
     end

data/lib/xsd/objects/import.rb

@@ -18,18 +18,20 @@ module XSD
     # Get imported schema
     # @return Schema
     def imported_schema
-      known_schemas = reader.schemas_for_namespace(namespace)
-      return known_schemas.first if known_schemas.any?
+      # a schema for the namespace may already be known, either added manually or by another import
+      known_schema = reader.schemas_for_namespace(namespace).find { |s| !s.equal?(schema) }
+      return known_schema if known_schema
 
       unless schema_location
-        raise ImportError, "Schema location not provided for namespace '#{namespace}', use add_schema_xml()/add_schema_node()"
+        raise ImportError,
+              "Schema location not provided for namespace '#{namespace}', use add_schema_xml()/add_schema_node()"
       end
 
-      xml = reader.resource_resolver.call(schema_location, namespace)
-      new_schema = reader.add_schema_xml(xml)
+      new_schema = reader.load_schema(schema_location, namespace: namespace, base: schema.location)
 
       unless namespace == new_schema.target_namespace
-        raise ImportError, 'Import namespace does not match imported schema targetNamespace'
+        raise ImportError, "Import namespace '#{namespace}' does not match imported schema targetNamespace " \
+                           "'#{new_schema.target_namespace}'"
       end
 
       new_schema

data/lib/xsd/objects/include.rb

@@ -10,20 +10,20 @@ module XSD
     # @return String
     property :schemaLocation, :string
 
-    # Get imported schema
+    # Get included schema
     # @return Schema
     def imported_schema
-      # cache included schema locally as it has no unique namespace to check in global registry
-      return @imported_schema if @imported_schema
+      raise ImportError, 'Schema location not provided for include' unless schema_location
 
-      xml = reader.resource_resolver.call(schema_location)
-      new_schema = reader.add_schema_xml(xml)
+      new_schema = reader.load_schema(schema_location, base: schema.location)
 
-      unless schema.target_namespace == new_schema.target_namespace
-        raise ImportError, 'Schema targetNamespace does not match included schema targetNamespace'
+      # an included schema without a target namespace adopts the namespace of the including schema ("chameleon" include)
+      unless new_schema.target_namespace.nil? || schema.target_namespace == new_schema.target_namespace
+        raise ImportError, "Schema targetNamespace '#{schema.target_namespace}' does not match included schema " \
+                           "targetNamespace '#{new_schema.target_namespace}'"
       end
 
-      @imported_schema = new_schema
+      new_schema
     end
   end
 end

data/lib/xsd/objects/restriction.rb

@@ -39,22 +39,20 @@ module XSD
     # Get restriction facets
     # @return Hash
     def facets
-      nodes.inject({}) do |hash, node|
-        if FACET_ELEMENTS.include?(node.name)
-          key   = node.name
-          value = node['value']
+      @facets ||= nodes.each_with_object({}) do |node, hash|
+        next unless FACET_ELEMENTS.include?(node.name)
 
-          if key == 'enumeration'
-            hash[key]        ||= {}
-            hash[key][value] = documentation_for(node)
-          elsif key == 'pattern'
-            hash[key] ||= []
-            hash[key].push(value)
-          else
-            hash[key] = value
-          end
+        key   = node.name
+        value = node['value']
+
+        case key
+        when 'enumeration'
+          (hash[key] ||= {})[value] = documentation_for(node)
+        when 'pattern'
+          (hash[key] ||= []).push(value)
+        else
+          hash[key] = value
         end
-        hash
       end
     end
 
@@ -73,7 +71,7 @@ module XSD
     def collect_attributes(include_base = true)
       result = super(include_base)
       # Filter restricted attributes to avoid duplicates from restricting and restricted type
-      include_base ? result.inject({}) { |hash, item| hash[item.name] = item; hash }.values : result
+      include_base ? result.to_h { |item| [item.name, item] }.values : result
     end
   end
 end

data/lib/xsd/objects/schema.rb

@@ -120,7 +120,13 @@ module XSD
     # Get schema namespace prefix
     # @return String, nil
     def namespace_prefix
-      nil_if_empty(@namespace_prefix ||= namespaces.key(XML_SCHEMA).sub(/^xmlns:?/, ''))
+      nil_if_empty(@namespace_prefix ||= namespaces.key(XML_SCHEMA)&.sub(/^xmlns:?/, '') || '')
+    end
+
+    # Location the schema was read from, used to resolve relative import/include locations
+    # @return String, nil
+    def location
+      options[:location]
     end
 
     # Check if namespace is a target namespace
@@ -132,26 +138,26 @@ module XSD
 
     # Override map_children on schema to get objects from all loaded schemas
     # @param [Symbol] name
+    # @param [Hash] cache Schema nodes already visited, guards against import/include cycles
     # @return Array<BaseObject>
     def map_children(name, cache = {})
+      cache[node] = true
       super(name) + import_map_children(name, cache)
     end
 
     # Get children from all loaded schemas
     # @param [Symbol] name
+    # @param [Hash] cache
     # @return Array<BaseObject>
     def import_map_children(name, cache)
       return [] if %i[import include].include?(name.to_sym)
 
-      (includes + imports).map do |import|
-        key = import.respond_to?(:namespace) && import.namespace ? import.namespace : import.schema_location
-        if cache.key?(key)
-          nil
-        else
-          cache[key] = true
-          import.imported_schema.map_children(name, cache)
-        end
-      end.compact.flatten
+      (includes + imports).flat_map do |import|
+        imported = import.imported_schema
+        next [] if cache.key?(imported.node)
+
+        imported.map_children(name, cache)
+      end
     end
 
     # Get import by namespace or prefix
@@ -170,7 +176,9 @@ module XSD
     # @param [String, Pathname, Nokogiri::XML::Document] xml
     def validate_xml(xml)
       # validate input
-      raise ValidationError unless xml.is_a?(Nokogiri::XML::Document) || xml.is_a?(Pathname) || xml.is_a?(String)
+      unless xml.is_a?(Nokogiri::XML::Document) || xml.is_a?(Pathname) || xml.is_a?(String)
+        raise ValidationError, "XML must be a String, Pathname or Nokogiri::XML::Document, got #{xml.class}"
+      end
 
       begin
         document = xml.is_a?(Nokogiri::XML::Document) ? xml : Nokogiri::XML(xml)
@@ -200,69 +208,61 @@ module XSD
     def schema_validator
       return @schema_validator if @schema_validator
 
-      # if !imported_xsd.empty?
-      # imports are explicitly provided - put all files in one tmpdir and update import paths appropriately
-      # TODO: save file/path map to display in errors
+      # imports/includes are resolved by the reader, so put all schemas in one tmpdir with rewritten locations
       Dir.mktmpdir('XSD', reader.tmp_dir) do |dir|
-        # create primary xsd file
-        file = "#{::SecureRandom.urlsafe_base64}.xsd"
-
-        # create imported xsd files
-        recursive_import_xsd(self, file, Set.new) do |f, data|
-          File.write("#{dir}/#{f}", data)
+        file = recursive_import_xsd(self, {}) do |name, data|
+          File.write(File.join(dir, name), data, encoding: Encoding::UTF_8)
         end
 
         # read schema from tmp file descriptor
-        io = File.open("#{dir}/#{file}")
-        @schema_validator = create_xml_schema(io)
+        File.open(File.join(dir, file)) { |io| @schema_validator = create_xml_schema(io) }
       end
-      # else
-      #   @schema_validator = create_xml_schema(schema.node.to_xml)
-      # end
 
       @schema_validator
     end
 
-    # Сформировать имена файлов и содержимое XSD схем для корректной валидации
+    # Write the schema and all of its imports/includes as a flat set of files with rewritten locations
     # @param [Schema] schema
-    # @param [String] file
-    # @param [Set] processed
-    def recursive_import_xsd(schema, file, processed, &block)
-      # handle recursion
-      return if processed.include?(schema.target_namespace)
-
-      processed.add(schema.target_namespace)
-
-      # prepare schema XML with all namespaces included, clone node to avoid mutating original schema
-      node = schema.node
-      if node.namespaces.size != node.namespace_definitions.size
-        prefixes = node.namespace_definitions.map(&:prefix)
-        node = schema.node.dup
-
-        schema.node.namespaces.each do |attr, ns|
-          prefix = attr == 'xmlns' ? nil : attr.sub('xmlns:', '')
-          # does not work!
-          # node.add_namespace_definition(prefix, ns) unless prefixes.include?(prefix)
-          node[attr] = ns unless prefixes.include?(prefix)
-        end
+    # @param [Hash] processed Maps already written schema nodes to generated file names
+    # @return String Name of the file the schema was written to
+    def recursive_import_xsd(schema, processed, &block)
+      # handle recursion, schemas are identified by node because includes share the target namespace
+      return processed[schema.node] if processed.key?(schema.node)
+
+      file = "#{::SecureRandom.urlsafe_base64}.xsd"
+      processed[schema.node] = file
+
+      node       = schema_node_with_namespaces(schema)
+      references = schema.imports + schema.includes
+      nodes      = node.xpath('./xs:import', XML_SCHEMA_NS).to_a + node.xpath('./xs:include', XML_SCHEMA_NS).to_a
+
+      # point every import/include to the generated file of the referenced schema
+      references.zip(nodes).each do |reference, reference_node|
+        next if reference_node.nil?
+
+        reference_node['schemaLocation'] = recursive_import_xsd(reference.imported_schema, processed, &block)
       end
 
-      data = node.to_xml
+      # always serialize as UTF-8 with an explicit declaration, the source document may use another encoding
+      block.call(file, %(<?xml version="1.0" encoding="UTF-8"?>\n#{node.to_xml(encoding: 'UTF-8')}))
 
-      schema.imports.each do |import|
-        name      = "#{::SecureRandom.urlsafe_base64}.xsd"
-        location  = import.schema_location
-        namespace = import.namespace
+      file
+    end
 
-        if location
-          data = data.sub("schemaLocation=\"#{location}\"", "schemaLocation=\"#{name}\"")
-        else
-          data = data.sub("namespace=\"#{namespace}\"", "namespace=\"#{namespace}\" schemaLocation=\"#{name}\"")
-        end
-        recursive_import_xsd(import.imported_schema, name, processed, &block)
+    # Get a detached copy of the schema node with all inherited namespaces declared on it
+    # @param [Schema] schema
+    # @return Nokogiri::XML::Node
+    def schema_node_with_namespaces(schema)
+      node = schema.node.dup
+      prefixes = schema.node.namespace_definitions.map(&:prefix)
+
+      schema.node.namespaces.each do |attr, ns|
+        prefix = attr == 'xmlns' ? nil : attr.sub('xmlns:', '')
+        # add_namespace_definition does not work on a detached node, declare the namespace as an attribute instead
+        node[attr] = ns unless prefixes.include?(prefix)
       end
 
-      block.call(file, data)
+      node
     end
 
     # Create Nokogiri XML Schema instance with preconfigured options

data/lib/xsd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module XSD
-  VERSION = '2.7.10'
+  VERSION = '2.8.0'
 end

data/lib/xsd/xml.rb

@@ -2,13 +2,21 @@
 
 require 'nokogiri'
 require 'net/http'
+require 'pathname'
+require 'logger'
+require 'uri'
 
 module XSD
   class XML
     attr_reader :options, :object_cache, :schemas
 
+    # Matches locations that have to be fetched over the network
+    REMOTE_LOCATION = %r{\Ahttps?://}i
+
+    # Legacy resource resolver, kept for backwards compatibility. Resolves absolute paths and URLs only,
+    # relative locations are resolved by the reader itself, see #read_resource
     DEFAULT_RESOURCE_RESOLVER = proc do |location, namespace|
-      if location =~ /^https?:/
+      if location.match?(REMOTE_LOCATION)
         Net::HTTP.get(URI(location))
       elsif Pathname.new(location).absolute?
         File.read(location)
@@ -62,31 +70,35 @@ module XSD
     }.freeze
 
     # Create reader from a file path
-    # @param [String] path
+    # @param [String, Pathname] path
     # @param [Hash] options
     # @return XML
     def self.open(path, **options)
       reader = new(**options)
-      reader.add_schema_xml(File.read(path))
+      reader.add_schema_xml(File.read(path.to_s), location: path.to_s)
       reader
     end
 
     def initialize(**options)
-      @options      = options
-      @object_cache = {}
-      @schemas      = []
+      @options              = options
+      # keyed by node identity, the parsed documents are treated as immutable
+      @object_cache         = {}.compare_by_identity
+      @schemas              = []
+      @schemas_by_location  = {}
     end
 
     def logger
       options[:logger] || default_logger
     end
 
+    # Resolver used to fetch imported/included schemas
+    # @return Proc
     def resource_resolver
       @options[:resource_resolver] || DEFAULT_RESOURCE_RESOLVER
     end
 
     def tmp_dir
-      @tmp_dir ||= options[:tmp_dir]
+      options[:tmp_dir]
     end
 
     def read_document(xml)
@@ -94,24 +106,51 @@ module XSD
     end
 
     # Add schema xml to reader instance
+    # @param [String] xml
+    # @param [String, nil] location Location the xml was read from, used to resolve relative imports
     # @return Schema
-    def add_schema_xml(xml)
+    def add_schema_xml(xml, location: nil)
       doc = read_document(xml)
       raise Error, 'Schema node not found, xml does not seem to be a valid XSD' unless doc.root&.name == 'schema'
 
-      add_schema_node(doc.root)
+      add_schema_node(doc.root, location: location)
     end
 
     # Add schema node to reader instance
+    # @param [Nokogiri::XML::Node] node
+    # @param [String, nil] location Location the node was read from, used to resolve relative imports
     # @return Schema
-    def add_schema_node(node)
+    def add_schema_node(node, location: nil)
       raise Error, 'Added schema must be of type Nokogiri::XML::Node' unless node.is_a?(Nokogiri::XML::Node)
 
-      new_schema = Schema.new(options.merge(node: node, reader: self))
+      new_schema = Schema.new(options.merge(node: node, reader: self, location: location))
       schemas.push(new_schema)
+      # register the schema so that an import/include pointing back at this location reuses it
+      @schemas_by_location[location] ||= new_schema if location
       new_schema
     end
 
+    # Load schema referenced by an import/include, reusing an already loaded one when possible
+    # @param [String] location
+    # @param [String, nil] namespace
+    # @param [String, nil] base Location of the referencing schema
+    # @return Schema
+    def load_schema(location, namespace: nil, base: nil)
+      raise ImportError, 'Schema location must be provided' if location.nil? || location.empty?
+
+      expanded = expand_location(location, base)
+      return @schemas_by_location[expanded] if @schemas_by_location.key?(expanded)
+
+      # a custom resolver is responsible for resolving relative locations on its own
+      xml = if options[:resource_resolver]
+              options[:resource_resolver].call(location, namespace)
+            else
+              read_resource(expanded, namespace)
+            end
+
+      @schemas_by_location[expanded] = add_schema_xml(xml, location: expanded)
+    end
+
     # Get first added (considered primary) schema
     # @return Schema, nil
     def schema
@@ -160,10 +199,34 @@ module XSD
 
     private
 
+    # Read schema contents from an absolute path or URL
+    # @param [String] location
+    # @param [String, nil] namespace
+    # @return String
+    def read_resource(location, namespace = nil)
+      if location.match?(REMOTE_LOCATION)
+        Net::HTTP.get(URI(location))
+      elsif File.file?(location)
+        File.read(location)
+      else
+        raise ImportError, "Failed to locate import '#{location}'#{namespace ? " for namespace '#{namespace}'" : ''}"
+      end
+    end
+
+    # Resolve a possibly relative location against the location of the referencing schema
+    # @param [String] location
+    # @param [String, nil] base
+    # @return String
+    def expand_location(location, base)
+      return location if location.match?(REMOTE_LOCATION) || Pathname.new(location).absolute?
+      return location if base.nil?
+      return URI.join(base, location).to_s if base.match?(REMOTE_LOCATION)
+
+      Pathname.new(base).dirname.join(location).cleanpath.to_s
+    end
+
     def collect(name, *args)
-      result = Set.new
-      schemas.each { |schema| result.merge(schema.send(name, *args)) }
-      result.to_a
+      schemas.flat_map { |schema| schema.send(name, *args) }.uniq
     end
 
     def default_logger

data/lib/xsd.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'xsd/version'
 require 'xsd/base_object'
 require 'xsd/shared/named'
 require 'xsd/shared/min_max_occurs'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.7.10
+  version: 2.8.0
 platform: ruby
 authors:
 - d.arkhipov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2026-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -55,7 +55,7 @@ dependencies:
 description: The Ruby XSD library is an XML Schema implementation for Ruby.Provides
   easy and flexible access to XSD information
 email:
-- d.arkhipov@netcitylife.ru
+- d.arkhipov@ekzo.dev
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -111,14 +111,13 @@ files:
 - lib/xsd/shared/simple_typed.rb
 - lib/xsd/version.rb
 - lib/xsd/xml.rb
-- xsd.gemspec
 homepage: https://github.com/ekzo-dev/ruby-xsd
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/ekzo-dev/ruby-xsd
   source_code_uri: https://github.com/ekzo-dev/ruby-xsd
-  changelog_uri: https://github.com/ekzo-dev/ruby-xsd/CHANGELOG.md
+  changelog_uri: https://github.com/ekzo-dev/ruby-xsd/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/xsd.gemspec

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/xsd/version'
-
-Gem::Specification.new do |spec|
-  spec.name    = 'xsd'
-  spec.version = XSD::VERSION
-  spec.authors = ['d.arkhipov']
-  spec.email   = ['d.arkhipov@netcitylife.ru']
-
-  spec.summary     = 'The Ruby XSD library is an XML Schema implementation for Ruby.'
-  spec.description =
-    'The Ruby XSD library is an XML Schema implementation for Ruby.Provides easy and flexible access to XSD information'
-
-  spec.homepage              = 'https://github.com/ekzo-dev/ruby-xsd'
-  spec.license               = 'MIT'
-  spec.required_ruby_version = '>= 2.7.0'
-
-  spec.metadata['homepage_uri']    = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri']   = 'https://github.com/ekzo-dev/ruby-xsd/CHANGELOG.md'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
-    end
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'builder', '~> 3.2'
-  spec.add_dependency 'nokogiri', '~> 1.11'
-  spec.add_dependency 'rake', '~> 13.0'
-end