xsd 2.9.1 → 2.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90d2e1e3950f8ada667ad7a2960940c3a4857918425c6fb54ef6c6a92702f1bc
-  data.tar.gz: 713e112c94582f982c01708d6ca735fd667006b476cb6ef0125383c55e39644b
+  metadata.gz: 178b66562e4da9833513bd00a12c528231551bac936eb7b72c611c9d3fc0a2bb
+  data.tar.gz: e58a38469f83f232583eb23f6fbefda81a86c56edf7cbfce06b305d81d3ce622
 SHA512:
-  metadata.gz: a804d3750423fe3c04c5d99614dac7a49679941498dacb9e9f72ef319c99da2c21ab70e94df58e38e7d0bae59561c66836c81db7df651ca68030baf363c96eab
-  data.tar.gz: 7ed63b4341d8a27a6fc1b3df4d3c6aebd30a2a5e101bf91ccaa32b54997b47f475d98c329c406eb5802706d4361b9ef6dc119a6422922726234391d124a202b2
+  metadata.gz: 7c34d9b9ee21284c3bc3d3b20a6f29de7ff94ac4dae1a85aaf2998dad74a35c043b612bac4691880ddefcddda42bf0734faef1fa64a63a984c301d020f3103ea
+  data.tar.gz: 9d846b4eaeff11247851889a133bcb62de24dad598764778be74a81d97d50b251f0257d95801c6aae8e09be588e7676c6aae2ad24e0806f8e8895ccb055f0c2b

data/.rubocop.yml

@@ -1,4 +1,4 @@
-require:
+plugins:
   - rubocop-performance
   - rubocop-rake
   - rubocop-rspec

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [2.9.3] - 2026-10-24
+
+### Fixed
+
+- A schema with no target namespace that imports another namespace (an XMLDSig `Signature` referenced as
+  `ds:SignatureType`) now finds what it imports. `Schema#targets_namespace?` took a namespace URI for a prefix, looked
+  it up among the schema's prefixes, found nothing, and matched that nothing against the absent target namespace:
+  every reference by a prefixed name was looked for in the schema itself.
+
+### Changed
+
+- Every import of the absent namespace is read from its own location. Schemas with no target namespace are each a
+  schema of their own (a provider's documents, every one shipping its own copies of the common types, which may
+  differ), so a second import of the absent namespace was not the same schema as the first one; before, it was
+  answered with whichever such schema had been loaded first. An import whose location is loaded already is answered
+  with that schema in any namespace (`XML#loaded_schema`); an import of a named namespace is still answered with a
+  schema known for it before its location is read.
+
+## [2.9.2] - 2026-10-21
+
+### Changed
+
+- A property, link or child of a schema object (`name`, `type`, `max_occurs`, `complex_type`, …) is read through a
+  method of its own, defined when the class declares it, instead of `method_missing`, which costs far more per call.
+  The lookup order is the same: a method a class or an ancestor defines itself still answers first, and
+  `respond_to?` answers as before. Reading XML against a large schema runs about 40% faster under YJIT.
+- `data_type` of an element, attribute, simple and complex type is worked out once and kept: the schema does not
+  change once read, and converting a document asked for it once per value.
+
 ## [2.9.1] - 2026-10-20
 
 ### Changed

data/Gemfile

@@ -8,8 +8,8 @@ gemspec
 group :development do
   gem 'logger', '~> 1.5'
   gem 'rspec', '~> 3.12'
-  gem 'rubocop', '~> 1.50'
-  gem 'rubocop-performance', '~> 1.17'
-  gem 'rubocop-rake', '~> 0.6'
-  gem 'rubocop-rspec', '~> 2.10'
+  gem 'rubocop', '~> 1.92'
+  gem 'rubocop-performance', '~> 1.27'
+  gem 'rubocop-rake', '~> 0.7'
+  gem 'rubocop-rspec', '~> 3.8'
 end

data/README.md

@@ -61,6 +61,16 @@ element.multiple_allowed? # => true
 element.required? # => false
 ```
 
+### Imports and the absent namespace
+
+XML Schema leaves it to the processor whether every `<xs:import>` of a namespace is read or only the first (a
+`schemaLocation` is a hint); libxml2, and so Nokogiri's validator, reads the first. This reader reads them all, and
+resolves a name within the include tree of the schema the name is written in. That is what a set of schemas with no
+target namespace needs when one schema imports them all: every document a schema of its own, with its own copies of
+common types that may differ from one copy to another. Put together into one schema they break the rule that names
+are unique within a namespace, so a validator assembling one schema of them (`Schema#validate_xml`, which validates
+through Nokogiri) sees only the first of them.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can

data/lib/xsd/base_object.rb

@@ -73,7 +73,7 @@ module XSD
     # @param [Boolean] deep
     # @return Nokogiri::XML::NodeSet
     def nodes(name = :*, deep = false)
-      node.xpath("./#{deep ? '/' : ''}xs:#{name}", XML_SCHEMA_NS)
+      node.xpath("./#{'/' if deep}xs:#{name}", XML_SCHEMA_NS)
     end
 
     # Get schemas by namespace or prefix
@@ -279,12 +279,14 @@ module XSD
     # @param [Symbol] type
     # @param [Hash] options
     def self.property(name, type, options = {}, &block)
-      properties[to_underscore(name)] = {
+      method = to_underscore(name)
+      properties[method] = {
         name: name,
         type: type,
         resolve: block,
         **options
       }
+      define_member_reader(method)
     end
 
     # Define new object child
@@ -292,10 +294,12 @@ module XSD
     # @param [Symbol, Array<Symbol>] type
     # @param [Hash] options
     def self.child(name, type, options = {})
-      children[to_underscore(name)] = {
+      method = to_underscore(name)
+      children[method] = {
         type: type,
         **options
       }
+      define_member_reader(method)
     end
 
     # Define new object child
@@ -303,16 +307,53 @@ module XSD
     # @param [Symbol] type
     # @param [Hash] options
     def self.link(name, type, options = {})
-      links[to_underscore(name)] = {
+      method = to_underscore(name)
+      links[method] = {
         type: type,
         **options
       }
+      define_member_reader(method)
     end
 
+    # A property, link or child is read through a method of its own: reaching it through method_missing costs far
+    # more per call, and an object is asked for its members all the time. The method goes in a module of the class's
+    # own, so that a method the class defines itself still wins, and is not defined where a method of that name
+    # exists already — an ancestor's own keeps answering, as it did when the name went to method_missing.
+    # @param [Symbol] method
+    def self.define_member_reader(method)
+      return if method_defined?(method) || private_method_defined?(method)
+
+      member_readers.define_method(method) do |*args|
+        value = read_member(method, args)
+        raise NoMethodError.new("undefined method '#{method}' for an instance of #{self.class}", method) if value.equal?(NOT_A_MEMBER)
+
+        value
+      end
+    end
+
+    # The module a class's member readers are defined in
+    # @return Module
+    def self.member_readers
+      @member_readers ||= Module.new.tap { |readers| include(readers) }
+    end
+
+    # What #read_member answers when the name is none of the object's members
+    NOT_A_MEMBER = Object.new.freeze
+
     # Lookup for properties
     # @param [Symbol] method
     # @param [Array] args
     def method_missing(method, *args)
+      value = read_member(method, args)
+      value.equal?(NOT_A_MEMBER) ? super : value
+    end
+
+    # The value of a property, link or child, cached: from the node, through a reference, or by its name in the
+    # schemas. A member reader and method_missing both come here.
+    # @param [Symbol] method
+    # @param [Array] args
+    # @return Object, NOT_A_MEMBER
+    def read_member(method, args)
       # check cache first, nil and false results are cached as well
       return @cache[method] if @cache.key?(method)
 
@@ -343,7 +384,7 @@ module XSD
         return @cache[method] = result
       end
 
-      super
+      NOT_A_MEMBER
     end
 
     # Does object has property/link/child?
@@ -368,7 +409,7 @@ module XSD
     # @param [String, nil] string
     # @return String, nil
     def nil_if_empty(string)
-      string&.empty? ? nil : string
+      string && string.empty? ? nil : string
     end
 
     private

data/lib/xsd/objects/attribute.rb

@@ -6,6 +6,8 @@ module XSD
   # extension (both simpleContent and complexContent)
   # https://www.w3schools.com/xml/el_attribute.asp
   class Attribute < BaseObject
+    prepend CachedDataType
+
     TYPE_PROPERTY = :type
 
     include SimpleTyped

data/lib/xsd/objects/complex_type.rb

@@ -6,6 +6,7 @@ module XSD
   # Parent elements: element, redefine, schema
   # https://www.w3schools.com/xml/el_complextype.asp
   class ComplexType < BaseObject
+    prepend CachedDataType
     include AttributeContainer
     include Named
 

data/lib/xsd/objects/element.rb

@@ -5,6 +5,8 @@ module XSD
   # Parent elements: schema, choice, all, sequence, group
   # https://www.w3schools.com/xml/el_element.asp
   class Element < BaseObject
+    prepend CachedDataType
+
     TYPE_PROPERTY = :type
 
     include MinMaxOccurs

data/lib/xsd/objects/import.rb

@@ -15,12 +15,21 @@ module XSD
     # @return String, nil
     property :schemaLocation, :string
 
-    # Get imported schema
+    # Get imported schema: the one at the import's location when that one is loaded already; otherwise one known for
+    # the namespace, added manually or by another import. Not for the absent namespace: schemas with no target
+    # namespace are each a schema of its own (a provider's documents, every one with its own copies of the common
+    # types), so every import of it is read from its own location.
     # @return Schema
     def imported_schema
-      # 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
+      if schema_location
+        located = reader.loaded_schema(schema_location, base: schema.location)
+        return located if located
+      end
+
+      unless namespace.nil?
+        known_schema = reader.schemas_for_namespace(namespace).find { |s| !s.equal?(schema) }
+        return known_schema if known_schema
+      end
 
       unless schema_location
         raise ImportError,

data/lib/xsd/objects/restriction.rb

@@ -62,14 +62,14 @@ module XSD
     def collect_elements(include_base = false)
       # Don't include elements from base by default, that will lead to element duplicates because
       # elements in complex restriction MUST be all listen in restricting type
-      super(include_base)
+      super
     end
 
     # Get all available attributes on the current stack level, optionally including base type attributes
     # @param [Boolean] include_base
     # @return Array<Attribute>
     def collect_attributes(include_base = true)
-      result = super(include_base)
+      result = super
       # Filter restricted attributes to avoid duplicates from restricting and restricted type
       include_base ? result.to_h { |item| [item.name, item] }.values : result
     end

data/lib/xsd/objects/schema.rb

@@ -190,7 +190,10 @@ module XSD
     # @param [String, nil] namespace
     # @return Boolean
     def targets_namespace?(namespace)
-      namespace == target_namespace || namespaces[namespace.nil? ? 'xmlns' : "xmlns:#{namespace}"] == target_namespace ||
+      key = namespace.nil? ? 'xmlns' : "xmlns:#{namespace}"
+      # a prefix names a namespace only when the schema declares it: looking up a namespace URI as a prefix finds
+      # nothing, and nothing must not pass for the absent target namespace of a schema that has none
+      namespace == target_namespace || (namespaces.key?(key) && namespaces[key] == 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

data/lib/xsd/objects/simple_type.rb

@@ -7,6 +7,7 @@ module XSD
   # https://www.w3schools.com/xml/el_simpletype.asp
   class SimpleType < BaseObject
     include Named
+    prepend CachedDataType
 
     # Specifies a name for the element. This attribute is required if the simpleType element is a child of the
     # schema element, otherwise it is not allowed

data/lib/xsd/objects/union.rb

@@ -9,7 +9,7 @@ module XSD
     # @!attribute member_types
     # @return Array<String>
     property :memberTypes, :array, default: [] do |union|
-      union.node['memberTypes']&.split(' ')
+      union.node['memberTypes']&.split
     end
 
     # Nested simple and built-in types

data/lib/xsd/shared/cached_data_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module XSD
+  # A definition's data type follows from the schema, which does not change once read: it is worked out on first use
+  # and kept. Reading XML casts every value by it, so it is asked for once per value otherwise.
+  module CachedDataType
+    def data_type
+      return @data_type if defined?(@data_type)
+
+      @data_type = super
+    end
+  end
+end

data/lib/xsd/version.rb

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

data/lib/xsd/xml.rb

@@ -21,7 +21,7 @@ module XSD
       elsif Pathname.new(location).absolute?
         File.read(location)
       else
-        raise ImportError, "Failed to locate import '#{location}'#{namespace ? " for namespace '#{namespace}'" : ''}"
+        raise ImportError, "Failed to locate import '#{location}'#{" for namespace '#{namespace}'" if namespace}"
       end
     end
 
@@ -158,6 +158,14 @@ module XSD
       @schemas_by_location[expanded] = add_schema_xml(xml, location: expanded)
     end
 
+    # The schema already read from a location, relative to a base as an import or an include names it
+    # @param [String] location
+    # @param [String, nil] base Location of the referencing schema
+    # @return Schema, nil
+    def loaded_schema(location, base: nil)
+      @schemas_by_location[expand_location(location.tr('\\', '/'), base)]
+    end
+
     # Get first added (considered primary) schema
     # @return Schema, nil
     def schema
@@ -256,7 +264,7 @@ module XSD
       elsif File.file?(location)
         File.read(location)
       else
-        raise ImportError, "Failed to locate import '#{location}'#{namespace ? " for namespace '#{namespace}'" : ''}"
+        raise ImportError, "Failed to locate import '#{location}'#{" for namespace '#{namespace}'" if namespace}"
       end
     end
 

data/lib/xsd.rb

@@ -10,6 +10,7 @@ require 'xsd/shared/element_container'
 require 'xsd/shared/based'
 require 'xsd/shared/simple_typed'
 require 'xsd/shared/complex_typed'
+require 'xsd/shared/cached_data_type'
 require 'xsd/objects/facet'
 require 'xsd/objects/attribute'
 require 'xsd/objects/attribute_group'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.9.1
+  version: 2.9.3
 platform: ruby
 authors:
 - d.arkhipov
@@ -102,6 +102,7 @@ files:
 - lib/xsd/objects/unique.rb
 - lib/xsd/shared/attribute_container.rb
 - lib/xsd/shared/based.rb
+- lib/xsd/shared/cached_data_type.rb
 - lib/xsd/shared/complex_typed.rb
 - lib/xsd/shared/element_container.rb
 - lib/xsd/shared/min_max_occurs.rb