xsd 2.8.1 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4ce386992542ac50581306a903b47c6f902db010c8f02a9894287231c15c0ba
-  data.tar.gz: c2f104eb7999dda90a472050ab09ab63659029cd3cbfede44206c67ad0765ae2
+  metadata.gz: 90d2e1e3950f8ada667ad7a2960940c3a4857918425c6fb54ef6c6a92702f1bc
+  data.tar.gz: 713e112c94582f982c01708d6ca735fd667006b476cb6ef0125383c55e39644b
 SHA512:
-  metadata.gz: 55b27a9f4a09b0c01f60a360b04ffd018645599edd9c7d7e8223a51be831905064b08a9e5e4cfd6cb285967692f355308bbd4acc2b3e5c0c1df91778df752fad
-  data.tar.gz: 51cebb0519a4817f94045b73e2c9609f9b9d9de40cd05c31769021e5d710e5ca47acdc159982ac8526bf0fdaeee4a621017994a97b3b9c9bd8514ce1dcfd658a
+  metadata.gz: a804d3750423fe3c04c5d99614dac7a49679941498dacb9e9f72ef319c99da2c21ab70e94df58e38e7d0bae59561c66836c81db7df651ca68030baf363c96eab
+  data.tar.gz: 7ed63b4341d8a27a6fc1b3df4d3c6aebd30a2a5e101bf91ccaa32b54997b47f475d98c329c406eb5802706d4361b9ef6dc119a6422922726234391d124a202b2

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [2.9.1] - 2026-10-20
+
+### Changed
+
+- A reference by name (a `type`, `ref`, `base`, …) is looked up in an index of the schema's top-level declarations
+  (`Schema#declaration_node`), built on the first lookup, instead of an XPath query that scanned every child of the
+  schema again for each reference. Large schemas referenced thousands of times are read several times faster
+  there; what is found is the same.
+- The specs no longer load `wasabi`, which only a commented-out example used and which does not load on Ruby 3.4
+  (it requires `kconv`): the suite runs on Ruby 3.4.
+
+## [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

data/Gemfile

@@ -12,5 +12,4 @@ group :development do
   gem 'rubocop-performance', '~> 1.17'
   gem 'rubocop-rake', '~> 0.6'
   gem 'rubocop-rspec', '~> 2.10'
-  gem 'wasabi', '~> 4.0'
 end

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
@@ -128,9 +129,9 @@ module XSD
       # determine schema for namespace
       search_schemas = schemas_for_namespace(name_prefix)
 
-      # find element in target schema, name is passed as an xpath variable to stay safe with any name contents
+      # find the declaration in the schemas of the namespace
       search_schemas.each do |s|
-        node = s.node.at_xpath("./xs:#{node_name}[@name=$name]", XML_SCHEMA_NS, name: name_local)
+        node = s.declaration_node(node_name, name_local)
         return s.node_to_object(node) if node
       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,63 @@ 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
+
+    # The node of a top-level declaration of this schema, by its kind and name — what a reference by name looks up
+    # (BaseObject#object_by_name). The children are indexed in one pass on the first lookup: a query per lookup
+    # scans all of them again, and a large schema is looked up in once for every reference to it.
+    # @param [Symbol, String] node_name kind of declaration: complexType, simpleType, element, group, ...
+    # @param [String] name local name
+    # @return Nokogiri::XML::Element, nil
+    def declaration_node(node_name, name)
+      @declaration_nodes ||= node.element_children.each_with_object({}) do |child, index|
+        next unless child.namespace&.href == XML_SCHEMA
+
+        # the first one, as a query would find it
+        index[[child.name, child['name']]] ||= child
+      end
+      @declaration_nodes[[node_name.to_s, name]]
+    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 +190,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 +213,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.1'
+  VERSION = '2.9.1'
 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
@@ -163,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
@@ -232,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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.9.1
 platform: ruby
 authors:
 - d.arkhipov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -119,7 +118,6 @@ 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/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -134,8 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: The Ruby XSD library is an XML Schema implementation for Ruby.
 test_files: []