xsd 2.9.1 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90d2e1e3950f8ada667ad7a2960940c3a4857918425c6fb54ef6c6a92702f1bc
-  data.tar.gz: 713e112c94582f982c01708d6ca735fd667006b476cb6ef0125383c55e39644b
+  metadata.gz: 81b3091d973a5f08501a01ba6d6b746b4863bc28b5392ec634c4d226b7775a98
+  data.tar.gz: 5bad6e4209bd42086a25d892a5c8a0845012ad91a57a97c7b80cf13f0656624b
 SHA512:
-  metadata.gz: a804d3750423fe3c04c5d99614dac7a49679941498dacb9e9f72ef319c99da2c21ab70e94df58e38e7d0bae59561c66836c81db7df651ca68030baf363c96eab
-  data.tar.gz: 7ed63b4341d8a27a6fc1b3df4d3c6aebd30a2a5e101bf91ccaa32b54997b47f475d98c329c406eb5802706d4361b9ef6dc119a6422922726234391d124a202b2
+  metadata.gz: fd1216b66f6d84f386850e5eb8160eadac25677d739a5c140eb64a974f300c7e0eca26f7c0d5a1fcd9fd8bb665c16d06c91776ea57d13b322e1b925dce35f765
+  data.tar.gz: 4a0145cebcb96eaf27b8a00fc7caf3be761a2d83b2809853f51c74c81702ae377168308a652ba716afd68fb2a7001b4a97ba713ea341c4983f11d14f8e007453

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [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/lib/xsd/base_object.rb

@@ -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/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.1'
+  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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.9.1
+  version: 2.9.2
 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