xsd 2.9.0 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dafeffb7f25c0134087002cfa7a33a2ae26bfb5d7aefc83dd998f73ce6551ce
-  data.tar.gz: 309a398a467318eb24d8912556010c11cba92f72419088b709540775dc270e00
+  metadata.gz: 81b3091d973a5f08501a01ba6d6b746b4863bc28b5392ec634c4d226b7775a98
+  data.tar.gz: 5bad6e4209bd42086a25d892a5c8a0845012ad91a57a97c7b80cf13f0656624b
 SHA512:
-  metadata.gz: 292b2948f27d88c4363149e41aabca8858cd3c9105b804c5e85231135f1deb9d1a2bab10a6868839721dfd866b75a6579aca43d9243ca115dd752597cbaa7d81
-  data.tar.gz: cdc5245afa7c4fd48064b8c6ddac6966d8e0010d8a98e23fc59b43eb3df98e2159f4912db2e4ca3c5610e7713f0af1d525b6137e1c5c74edd38b8d87896c0717
+  metadata.gz: fd1216b66f6d84f386850e5eb8160eadac25677d739a5c140eb64a974f300c7e0eca26f7c0d5a1fcd9fd8bb665c16d06c91776ea57d13b322e1b925dce35f765
+  data.tar.gz: 4a0145cebcb96eaf27b8a00fc7caf3be761a2d83b2809853f51c74c81702ae377168308a652ba716afd68fb2a7001b4a97ba713ea341c4983f11d14f8e007453

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [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
+
+- 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

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

@@ -129,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
 
@@ -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?

data/lib/xsd/objects/attribute.rb

@@ -6,6 +6,7 @@ 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,7 @@ 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/schema.rb

@@ -127,6 +127,22 @@ module XSD
       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

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/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.0'
+  VERSION = '2.9.2'
 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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.9.2
 platform: ruby
 authors:
 - d.arkhipov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -103,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
@@ -119,7 +119,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 +133,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: []