xsd 2.8.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40e6cbfb1356c6d21529ad7339f3ada85dbf85be27d7d0fcd3ecd59e55250192
-  data.tar.gz: 544ea96a3cc35ac6a37f8ab8971ae7d30c1b4a89c11c80ae6475ad1fcc61a6ae
+  metadata.gz: 6dafeffb7f25c0134087002cfa7a33a2ae26bfb5d7aefc83dd998f73ce6551ce
+  data.tar.gz: 309a398a467318eb24d8912556010c11cba92f72419088b709540775dc270e00
 SHA512:
-  metadata.gz: 6fbc961bab3eac175a05dd99a8cbb34dce5384f682def039f708407f281cbbbe75f5ec6a57a751fff2c8fbad927fd83edf2b1e8e488f255655777a0ce7cf36d0
-  data.tar.gz: 4f8c2fa9687ed1f4647e91884abd60d63be92fcbda2475cc3b0aa3b340f9ca6ae7fbe12d91343389de1cd0616a676c45e018e88e8dcbe557d7014ce24c02d227
+  metadata.gz: 292b2948f27d88c4363149e41aabca8858cd3c9105b804c5e85231135f1deb9d1a2bab10a6868839721dfd866b75a6579aca43d9243ca115dd752597cbaa7d81
+  data.tar.gz: cdc5245afa7c4fd48064b8c6ddac6966d8e0010d8a98e23fc59b43eb3df98e2159f4912db2e4ca3c5610e7713f0af1d525b6137e1c5c74edd38b8d87896c0717

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## [2.9.0] - 2026-10-18
+
+### Changed
+
+- A schema with no target namespace included into one that has a namespace ("chameleon" include) is seen through
+  a view in the including namespace (`XML#chameleon`, `Schema#chameleon?`, `#chameleon_source`). Everything it
+  declares reports that namespace (`namespace`, `absolute_name`, `Schema#target_namespace`), and an unqualified
+  name inside it resolves in that namespace. Before, its definitions reported no namespace at all.
+- A schema included into two namespaces declares two sets of definitions, one per namespace: a view keeps its own
+  object cache (`Schema#object_cache`), where one object per node used to serve both.
+- `XML#schemas_for_namespace` returns what the schemas of the namespace include as well, chameleon views among
+  them, and so does the lookup of a referenced name: includes of includes, and what a schema reached through an
+  import includes (only the schema itself, or one level of includes, was searched). A schema only seen through a
+  chameleon view is no longer among those of the absent namespace
+- `XML#[]` and the collectors (`elements`, `complex_types`, `simple_types`, …) go through the schemas that stand
+  on their own (`XML#standalone_schemas`): a schema only seen through a chameleon view contributes its
+  definitions through the schemas including it, not a second time in the absent namespace
+
+### Added
+
+- `XML#target_namespaces`: every namespace the schemas declare definitions in, includes resolved; the absent
+  namespace (nil) only for a schema with no namespace that nothing includes
+
+## [2.8.1] - 2026-10-18
+
+### Fixed
+
+- An import/include location written with backslashes (`import\types.xsd`) is resolved as one written with
+  slashes. A `schemaLocation` is a URI reference, but schemas authored on Windows carry such locations; a custom
+  resource resolver is handed the location so normalized
+
 ## [2.8.0] - 2026-09-21
 
 ### Fixed

data/lib/xsd/base_object.rb

@@ -85,9 +85,10 @@ module XSD
       ns = prefix || ns_or_prefix
 
       if schema.targets_namespace?(ns)
-        [schema, *schema.includes.map(&:imported_schema)]
+        schema.with_includes
       elsif (import = schema.import_by_namespace(ns))
-        [import.imported_schema]
+        # what the imported schema includes is part of its namespace too
+        import.imported_schema.with_includes
       else
         raise Error, "Schema not found for namespace '#{ns}' in '#{schema.id || schema.target_namespace}'"
       end
@@ -141,14 +142,15 @@ module XSD
     # @param [Nokogiri::XML::Node] node
     # @return BaseObject
     def node_to_object(node)
-      # check object in cache first
-      cached = reader.object_cache[node]
+      # check object in cache first; a chameleon view keeps a cache of its own (see Schema#object_cache)
+      cache = schema.object_cache
+      cached = 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] = klass.new(options.merge(node: node, schema: schema))
+      cache[node] = klass.new(options.merge(node: node, schema: schema))
     end
 
     # Get xml parent object

data/lib/xsd/objects/include.rb

@@ -17,7 +17,12 @@ module XSD
 
       new_schema = reader.load_schema(schema_location, base: schema.location)
 
-      # an included schema without a target namespace adopts the namespace of the including schema ("chameleon" include)
+      # an included schema without a target namespace adopts the namespace of the including schema ("chameleon"
+      # include): what it declares belongs to that namespace, so it is seen through a view that says so
+      if new_schema.target_namespace.nil? && !schema.target_namespace.nil?
+        return reader.chameleon(new_schema, schema.target_namespace)
+      end
+
       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}'"

data/lib/xsd/objects/schema.rb

@@ -99,6 +99,47 @@ module XSD
       self
     end
 
+    # Target namespace of the schema. For a chameleon view (see XML#chameleon), the namespace of the schema
+    # that includes it — the one everything it declares belongs to.
+    # @return String, nil
+    def target_namespace
+      return options[:chameleon_namespace] if chameleon?
+
+      method_missing(:target_namespace)
+    end
+
+    # Is this a schema with no target namespace, seen as part of the namespace of a schema including it?
+    # @return Boolean
+    def chameleon?
+      options.key?(:chameleon_namespace)
+    end
+
+    # The schema a chameleon view is a view of
+    # @return Schema, nil
+    def chameleon_source
+      options[:chameleon_source]
+    end
+
+    # Objects made of this schema's nodes. A chameleon view keeps its own: the same node is a different
+    # definition in each namespace that includes it.
+    # @return Hash
+    def object_cache
+      chameleon? ? (@object_cache ||= {}.compare_by_identity) : reader.object_cache
+    end
+
+    # This schema and every schema it includes, those included in turn too
+    # @return Array<Schema>
+    def with_includes
+      found = [self]
+      found.each do |schema|
+        schema.includes.each do |include|
+          included = include.imported_schema
+          found << included unless found.any? { |known| known.equal?(included) }
+        end
+      end
+      found
+    end
+
     # Get all available elements on the current stack level, for schema same as elements
     # @return Array<Element>
     def collect_elements(*)
@@ -133,15 +174,17 @@ module XSD
     # @param [String, nil] namespace
     # @return Boolean
     def targets_namespace?(namespace)
-      namespace == target_namespace || namespaces[namespace.nil? ? 'xmlns' : "xmlns:#{namespace}"] == target_namespace
+      namespace == target_namespace || namespaces[namespace.nil? ? 'xmlns' : "xmlns:#{namespace}"] == target_namespace ||
+        # an unqualified name in a chameleon schema names something of the namespace it was included into
+        (chameleon? && namespace.nil? && !namespaces.key?('xmlns'))
     end
 
     # 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
+    def map_children(name, cache = {}.compare_by_identity)
+      cache[self] = true
       super(name) + import_map_children(name, cache)
     end
 
@@ -154,7 +197,7 @@ module XSD
 
       (includes + imports).flat_map do |import|
         imported = import.imported_schema
-        next [] if cache.key?(imported.node)
+        next [] if cache.key?(imported)
 
         imported.map_children(name, cache)
       end

data/lib/xsd/version.rb

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

data/lib/xsd/xml.rb

@@ -85,6 +85,7 @@ module XSD
       @object_cache         = {}.compare_by_identity
       @schemas              = []
       @schemas_by_location  = {}
+      @chameleons           = {}
     end
 
     def logger
@@ -130,7 +131,12 @@ module XSD
       new_schema
     end
 
-    # Load schema referenced by an import/include, reusing an already loaded one when possible
+    # Load schema referenced by an import/include, reusing an already loaded one when possible.
+    #
+    # A location written with backslashes (`import\types.xsd`) is read as one written with slashes: a
+    # `schemaLocation` is a URI reference, where the separator is `/` alone, but schemas authored on Windows
+    # carry such locations, and the tools they were made with accept them. A custom resolver is handed the
+    # location so normalized.
     # @param [String] location
     # @param [String, nil] namespace
     # @param [String, nil] base Location of the referencing schema
@@ -138,6 +144,7 @@ module XSD
     def load_schema(location, namespace: nil, base: nil)
       raise ImportError, 'Schema location must be provided' if location.nil? || location.empty?
 
+      location = location.tr('\\', '/')
       expanded = expand_location(location, base)
       return @schemas_by_location[expanded] if @schemas_by_location.key?(expanded)
 
@@ -157,15 +164,55 @@ module XSD
       schemas.first
     end
 
-    # Get schemas by namespace
+    # Get schemas by namespace: those that target it, and what they include — a chameleon schema (one with no
+    # target namespace of its own) as a view in this namespace
     # @param [String, nil] namespace
     # @return Array<Schema>
     def schemas_for_namespace(namespace)
-      schemas.select { |schema| schema.target_namespace == namespace }
+      found = []
+      # a schema only seen through a chameleon view is not one of the absent namespace
+      standalone_schemas.select { |schema| schema.target_namespace == namespace }.each do |schema|
+        schema.with_includes.each { |included| found << included unless found.any? { |known| known.equal?(included) } }
+      end
+      found
+    end
+
+    # A schema with no target namespace, seen as part of the namespace of a schema that includes it ("chameleon"
+    # include): the same document, with everything it declares in that namespace. One view per schema and
+    # namespace, so a schema included into two namespaces declares two sets of definitions.
+    # @param [Schema] source
+    # @param [String] namespace
+    # @return Schema
+    def chameleon(source, namespace)
+      @chameleons[[source.object_id, namespace]] ||=
+        Schema.new(source.options.merge(chameleon_namespace: namespace, chameleon_source: source))
+    end
+
+    # The chameleon views made so far
+    # @return Array<Schema>
+    def chameleons
+      @chameleons.values
+    end
+
+    # Every namespace the schemas declare definitions in, includes resolved. A schema with no target namespace
+    # stands for the absent namespace (nil) only when no schema includes it: otherwise what it declares is part
+    # of the namespaces including it.
+    # @return Array<String, nil>
+    def target_namespaces
+      (standalone_schemas + chameleons).map(&:target_namespace).uniq
+    end
+
+    # The schemas that stand on their own, includes resolved: all but those only seen through a chameleon view,
+    # whose definitions belong to the namespaces including them
+    # @return Array<Schema>
+    def standalone_schemas
+      schemas.each(&:with_includes)
+      sources = chameleons.map(&:chameleon_source)
+      schemas.reject { |schema| sources.any? { |source| source.equal?(schema) } }
     end
 
     def [](*args)
-      schemas.each do |schema|
+      standalone_schemas.each do |schema|
         item = schema[*args]
         return item if item
       end
@@ -226,7 +273,7 @@ module XSD
     end
 
     def collect(name, *args)
-      schemas.flat_map { |schema| schema.send(name, *args) }.uniq
+      standalone_schemas.flat_map { |schema| schema.send(name, *args) }.uniq
     end
 
     def default_logger

data/xsd.gemspec

@@ -0,0 +1,37 @@
+# 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@ekzo.dev']
+
+  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/blob/main/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.9.0
 platform: ruby
 authors:
 - d.arkhipov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-21 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -111,6 +111,7 @@ 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