lutaml-model 0.8.37 → 0.8.39

data/lib/lutaml/model/serialize/deserialization_context.rb

@@ -29,6 +29,7 @@ module Lutaml
           import_declaration_plan
           polymorphic
           collection
+          __lutaml_child_memo
           render_empty
           render_nil
           cdata

data/lib/lutaml/model/serialize.rb

@@ -33,6 +33,16 @@ module Lutaml
       # The getter materializes a real Array on first access.
       LAZY_EMPTY_COLLECTION = [].freeze
 
+      # Ivar symbols for lazy collections, memoized per attribute name:
+      # the "@name" interpolation allocated twice per collection read
+      # (491k on the ISO-13849 serialize profile).
+      LAZY_IVAR = {}.compare_by_identity
+
+      # Sentinel distinguishing "getter called with no argument" from
+      # builder-syntax `g.attr(value)` where value may be nil. Compiled
+      # getters default to it instead of a `*args` splat.
+      NO_ARG = Object.new.freeze
+
       INTERNAL_ATTRIBUTES = %i[@using_default @lutaml_register @lutaml_parent @lutaml_root
                                @register_records].freeze
 
@@ -73,6 +83,49 @@ module Lutaml
         end
       end
 
+      # lutaml-model#436: multi-document streams. `from_<f>_stream`
+      # parses each document separately; `discriminator:` receives each
+      # parsed document hash and returns the model class to build with,
+      # enabling polymorphic streams. `to_<f>_stream` joins instances
+      # into one stream document.
+      def self.register_stream_methods(format)
+        ClassMethods.define_method(:"from_#{format}_stream") do |data, options = {}|
+          docs = Lutaml::Model::Serialize.stream_documents(data, format, options)
+          discriminator = options[:discriminator]
+          docs.map do |doc|
+            target = discriminator ? discriminator.call(doc) : self
+            target.send(:"of_#{format}", doc, options)
+          end
+        end
+
+        ClassMethods.define_method(:"to_#{format}_stream") do |instances, options = {}|
+          instances.map do |instance|
+            instance.send(:"to_#{format}", options)
+          end.join("---\n")
+        end
+      end
+
+      def self.stream_documents(data, format, options)
+        require "yaml"
+        if YAML.respond_to?(:load_stream, true)
+          begin
+            docs = YAML.load_stream(data,
+                                    aliases: options.fetch(:aliases, true))
+          rescue ArgumentError
+            # Older Psych builds without the aliases keyword: aliases are
+            # on by default there.
+            docs = YAML.load_stream(data)
+          end
+          docs.is_a?(Array) ? docs.compact : [docs].compact
+        else
+          data.split(/^---\s*$/).filter_map do |chunk|
+            chunk.strip.empty? ? nil : YAML.safe_load(chunk)
+          end
+        end
+      rescue StandardError => e
+        raise Lutaml::Model::InvalidFormatError.new(format, e.message)
+      end
+
       def self.register_to_format_method(format)
         ClassMethods.define_method(:"to_#{format}") do |instance, options = {}|
           to(format, instance, options)
@@ -108,21 +161,12 @@ module Lutaml
         @using_default = nil
         @lutaml_register = register
 
-        # Default register: seed through the per-class compiled method
-        # (plain `@x = sentinel` writes). The previous per-instance
-        # instance_variable_set loop was a measured hot spot — one send
-        # and one symbol allocation per attribute per instance. Register-
-        # specific attribute sets are rare and keep the generic walk.
-        if register.nil? || register == :default
-          klass = self.class
-          klass.compile_state_defaults! unless klass.method_defined?(:__init_deserialized_state_defaults)
-          __init_deserialized_state_defaults
-        else
-          self.class.attributes(register).each do |name, attr|
-            instance_variable_set(:"@#{name}",
-                                  attr.collection? ? LAZY_EMPTY_COLLECTION : Lutaml::Model::UninitializedClass.instance)
-          end
-        end
+        # Seed every attribute through the per-(class, register) compiled
+        # method: plain `@x = sentinel` writes, no per-call "@#{name}"
+        # string interpolation, no instance_variable_set. The previous
+        # generic walk interpolated a name string per attribute per
+        # instance — 581k allocations on the ISO-13849 profile.
+        public_send(self.class.compiled_state_defaults_name!(self.class.extract_register_id(register)))
       end
 
       # Complete deserialization initialization after allocation.
@@ -367,11 +411,16 @@ module Lutaml
       # @param attribute_name [Symbol] the collection attribute
       # @return [Object] the stored collection
       def materialize_lazy_collection(attribute_name)
-        current = instance_variable_get(:"@#{attribute_name}")
+        ivar = LAZY_IVAR[attribute_name]
+        unless ivar
+          ivar = :"@#{attribute_name}"
+          LAZY_IVAR[attribute_name] = ivar
+        end
+        current = instance_variable_get(ivar)
         return current unless current.equal?(LAZY_EMPTY_COLLECTION)
         return current if frozen?
 
-        instance_variable_set(:"@#{attribute_name}", [])
+        instance_variable_set(ivar, [])
       end
 
       # Hand back a reference collection the caller can push onto.

data/lib/lutaml/model/services/transformer.rb

@@ -2,8 +2,8 @@ module Lutaml
   module Model
     class Transformer
       class << self
-        def call(value, rule, attribute, format: nil)
-          new(rule, attribute, format).call(value)
+        def call(value, rule, attribute, format: nil, context: nil)
+          new(rule, attribute, format, context).call(value)
         end
 
         private
@@ -15,7 +15,7 @@ module Lutaml
           transform.is_a?(::Hash) ? transform[direction] : transform
         end
 
-        def apply_static(value, sources, direction, format)
+        def apply_static(value, sources, direction, format, context = nil)
           methods = sources.filter_map do |obj|
             get_transform_static(obj, direction)
           end
@@ -34,16 +34,23 @@ module Lutaml
             tc.public_send(apply_direction, v, format)
           end
 
-          methods.reduce(result) { |tv, m| m.call(tv) }
+          methods.reduce(result) do |tv, m|
+            if m.arity == 2
+              m.call(tv, context)
+            else
+              m.call(tv)
+            end
+          end
         end
       end
 
-      attr_reader :rule, :attribute, :format
+      attr_reader :rule, :attribute, :format, :context
 
-      def initialize(rule, attribute, format = nil)
+      def initialize(rule, attribute, format = nil, context = nil)
         @rule = rule
         @attribute = attribute
         @format = format
+        @context = context
       end
 
       def call(value)
@@ -61,7 +68,19 @@ module Lutaml
         end
 
         methods.reduce(result) do |transformed_value, method|
-          method.call(transformed_value)
+          invoke_transform(method, transformed_value)
+        end
+      end
+
+      # lutaml-model#550: `with:` custom methods opt into the options
+      # passed to `from_*` / `to_*` by declaring a second parameter
+      # (exact arity 2); one-parameter methods keep the historical
+      # single-argument call.
+      def invoke_transform(method, value)
+        if method.arity == 2
+          method.call(value, context)
+        else
+          method.call(value)
         end
       end
 
@@ -87,8 +106,8 @@ module Lutaml
 
     class ImportTransformer < Transformer
       class << self
-        def call(value, rule, attribute, format: nil)
-          apply_static(value, [rule, attribute], :import, format)
+        def call(value, rule, attribute, format: nil, context: nil)
+          apply_static(value, [rule, attribute], :import, format, context)
         end
       end
 
@@ -103,8 +122,8 @@ module Lutaml
 
     class ExportTransformer < Transformer
       class << self
-        def call(value, rule, attribute, format: nil)
-          apply_static(value, [attribute, rule], :export, format)
+        def call(value, rule, attribute, format: nil, context: nil)
+          apply_static(value, [attribute, rule], :export, format, context)
         end
       end
 

data/lib/lutaml/model/type/string.rb

@@ -19,7 +19,10 @@ module Lutaml
           end
 
           value = value.to_s
-          value = value.gsub(/[\t\n\r]/, " ") unless mode == :preserve
+          # tr, not gsub: the regexp engine is measurable on hot text
+          # paths; :collapse keeps squeeze+strip (two C passes, no
+          # intermediate regexp state).
+          value = value.tr("\t\n\r", " ") unless mode == :preserve
           value = value.squeeze(" ").strip if mode == :collapse
 
           unless options.equal?(EMPTY_OPTIONS)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.37"
+    VERSION = "0.8.39"
   end
 end

data/lib/lutaml/xml/format.rb

@@ -21,6 +21,7 @@ end
 
 module Lutaml
   module Xml
+    autoload :HtmlEntities, "#{__dir__}/html_entities"
     autoload :PlanCompiler, "#{__dir__}/plan_compiler"
     autoload :PlanHydrator, "#{__dir__}/plan_hydrator"
     autoload :PlanOrder, "#{__dir__}/plan_order"

data/lib/lutaml/xml/html_entities.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+# lutaml-model#154: HTML 4.01 named entity table (plus apos) for opt-in
+# decoding of HTML entities in XML text (MathML and friends rely on
+# them although XML itself defines none beyond the predefined five).
+
+module Lutaml
+  module Xml
+    module HtmlEntities
+      # The table is the data: a gem dependency or data file for a static
+      # W3C list would cost more than the frozen literal itself.
+      # The table is the data: a gem dependency or data file for a static
+      # W3C list would cost more than the frozen literal itself.
+      NAMED_TO_CODEPOINT = { # rubocop:disable Metrics/CollectionLiteralLength
+        "AElig" => 198,
+        "Aacute" => 193,
+        "Acirc" => 194,
+        "Agrave" => 192,
+        "Alpha" => 913,
+        "Aring" => 197,
+        "Atilde" => 195,
+        "Auml" => 196,
+        "Beta" => 914,
+        "Ccedil" => 199,
+        "Chi" => 935,
+        "Dagger" => 8225,
+        "Delta" => 916,
+        "ETH" => 208,
+        "Eacute" => 201,
+        "Ecirc" => 202,
+        "Egrave" => 200,
+        "Epsilon" => 917,
+        "Eta" => 919,
+        "Euml" => 203,
+        "Gamma" => 915,
+        "Iacute" => 205,
+        "Icirc" => 206,
+        "Igrave" => 204,
+        "Iota" => 921,
+        "Iuml" => 207,
+        "Kappa" => 922,
+        "Lambda" => 923,
+        "Mu" => 924,
+        "Ntilde" => 209,
+        "Nu" => 925,
+        "OElig" => 338,
+        "Oacute" => 211,
+        "Ocirc" => 212,
+        "Ograve" => 210,
+        "Omega" => 937,
+        "Omicron" => 927,
+        "Oslash" => 216,
+        "Otilde" => 213,
+        "Ouml" => 214,
+        "Phi" => 934,
+        "Pi" => 928,
+        "Prime" => 8243,
+        "Psi" => 936,
+        "Rho" => 929,
+        "Scaron" => 352,
+        "Sigma" => 931,
+        "THORN" => 222,
+        "Tau" => 932,
+        "Theta" => 920,
+        "Uacute" => 218,
+        "Ucirc" => 219,
+        "Ugrave" => 217,
+        "Upsilon" => 933,
+        "Uuml" => 220,
+        "Xi" => 926,
+        "Yacute" => 221,
+        "Yuml" => 376,
+        "Zeta" => 918,
+        "aacute" => 225,
+        "acirc" => 226,
+        "acute" => 180,
+        "aelig" => 230,
+        "agrave" => 224,
+        "alefsym" => 8501,
+        "alpha" => 945,
+        "amp" => 38,
+        "and" => 8743,
+        "ang" => 8736,
+        "apos" => 39,
+        "aring" => 229,
+        "asymp" => 8776,
+        "atilde" => 227,
+        "auml" => 228,
+        "bdquo" => 8222,
+        "beta" => 946,
+        "brvbar" => 166,
+        "bull" => 8226,
+        "cap" => 8745,
+        "ccedil" => 231,
+        "cedil" => 184,
+        "cent" => 162,
+        "chi" => 967,
+        "circ" => 710,
+        "clubs" => 9827,
+        "cong" => 8773,
+        "copy" => 169,
+        "crarr" => 8629,
+        "cup" => 8746,
+        "curren" => 164,
+        "dArr" => 8659,
+        "dagger" => 8224,
+        "darr" => 8595,
+        "deg" => 176,
+        "delta" => 948,
+        "diams" => 9830,
+        "divide" => 247,
+        "eacute" => 233,
+        "ecirc" => 234,
+        "egrave" => 232,
+        "empty" => 8709,
+        "emsp" => 8195,
+        "ensp" => 8194,
+        "epsilon" => 949,
+        "equiv" => 8801,
+        "eta" => 951,
+        "eth" => 240,
+        "euml" => 235,
+        "euro" => 8364,
+        "exist" => 8707,
+        "fnof" => 402,
+        "forall" => 8704,
+        "frac12" => 189,
+        "frac14" => 188,
+        "frac34" => 190,
+        "frasl" => 8260,
+        "gamma" => 947,
+        "ge" => 8805,
+        "gt" => 62,
+        "hArr" => 8660,
+        "harr" => 8596,
+        "hearts" => 9829,
+        "hellip" => 8230,
+        "iacute" => 237,
+        "icirc" => 238,
+        "iexcl" => 161,
+        "igrave" => 236,
+        "image" => 8465,
+        "infin" => 8734,
+        "int" => 8747,
+        "iota" => 953,
+        "iquest" => 191,
+        "isin" => 8712,
+        "iuml" => 239,
+        "kappa" => 954,
+        "lArr" => 8656,
+        "lambda" => 955,
+        "lang" => 9001,
+        "laquo" => 171,
+        "larr" => 8592,
+        "lceil" => 8968,
+        "ldquo" => 8220,
+        "le" => 8804,
+        "lfloor" => 8970,
+        "lowast" => 8727,
+        "loz" => 9674,
+        "lrm" => 8206,
+        "lsaquo" => 8249,
+        "lsquo" => 8216,
+        "lt" => 60,
+        "macr" => 175,
+        "mdash" => 8212,
+        "micro" => 181,
+        "middot" => 183,
+        "minus" => 8722,
+        "mu" => 956,
+        "nabla" => 8711,
+        "nbsp" => 160,
+        "ndash" => 8211,
+        "ne" => 8800,
+        "ni" => 8715,
+        "not" => 172,
+        "notin" => 8713,
+        "nsub" => 8836,
+        "ntilde" => 241,
+        "nu" => 957,
+        "oacute" => 243,
+        "ocirc" => 244,
+        "oelig" => 339,
+        "ograve" => 242,
+        "oline" => 8254,
+        "omega" => 969,
+        "omicron" => 959,
+        "oplus" => 8853,
+        "or" => 8744,
+        "ordf" => 170,
+        "ordm" => 186,
+        "oslash" => 248,
+        "otilde" => 245,
+        "otimes" => 8855,
+        "ouml" => 246,
+        "para" => 182,
+        "part" => 8706,
+        "permil" => 8240,
+        "perp" => 8869,
+        "phi" => 966,
+        "pi" => 960,
+        "piv" => 982,
+        "plusmn" => 177,
+        "pound" => 163,
+        "prime" => 8242,
+        "prod" => 8719,
+        "prop" => 8733,
+        "psi" => 968,
+        "quot" => 34,
+        "rArr" => 8658,
+        "radic" => 8730,
+        "rang" => 9002,
+        "raquo" => 187,
+        "rarr" => 8594,
+        "rceil" => 8969,
+        "rdquo" => 8221,
+        "real" => 8476,
+        "reg" => 174,
+        "rfloor" => 8971,
+        "rho" => 961,
+        "rlm" => 8207,
+        "rsaquo" => 8250,
+        "rsquo" => 8217,
+        "sbquo" => 8218,
+        "scaron" => 353,
+        "sdot" => 8901,
+        "sect" => 167,
+        "shy" => 173,
+        "sigma" => 963,
+        "sigmaf" => 962,
+        "sim" => 8764,
+        "spades" => 9824,
+        "sub" => 8834,
+        "sube" => 8838,
+        "sum" => 8721,
+        "sup" => 8835,
+        "sup1" => 185,
+        "sup2" => 178,
+        "sup3" => 179,
+        "supe" => 8839,
+        "szlig" => 223,
+        "tau" => 964,
+        "there4" => 8756,
+        "theta" => 952,
+        "thetasym" => 977,
+        "thinsp" => 8201,
+        "thorn" => 254,
+        "tilde" => 732,
+        "times" => 215,
+        "trade" => 8482,
+        "uArr" => 8657,
+        "uacute" => 250,
+        "uarr" => 8593,
+        "ucirc" => 251,
+        "ugrave" => 249,
+        "uml" => 168,
+        "upsih" => 978,
+        "upsilon" => 965,
+        "uuml" => 252,
+        "weierp" => 8472,
+        "xi" => 958,
+        "yacute" => 253,
+        "yen" => 165,
+        "yuml" => 255,
+        "zeta" => 950,
+        "zwj" => 8205,
+        "zwnj" => 8204,
+      }.freeze
+
+      NAME_PATTERN = /&(#x?[0-9A-Fa-f]+|[A-Za-z][A-Za-z0-9]*);/
+
+      module_function
+
+      def decode(value)
+        value.gsub(NAME_PATTERN) do |match|
+          body = match[1..-2]
+          case body[0]
+          when "x", "X"
+            body[1..].to_i(16).chr(Encoding::UTF_8)
+          when "#"
+            body[1..].to_i.chr(Encoding::UTF_8)
+          else
+            codepoint = NAMED_TO_CODEPOINT[body]
+            codepoint ? codepoint.chr(Encoding::UTF_8) : match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/mapping.rb

@@ -121,9 +121,16 @@ module Lutaml
         @cached_attributes.clear
         @cached_mappings.clear
         @cached_attribute_name_counts.clear
+        @rule_records_version = (@rule_records_version || 0) + 1
         @finalized = true
       end
 
+      # Bumped at finalize; ModelTransform's compiled rule records are
+      # keyed on it so late mapping changes rebuild instead of going stale.
+      def rule_records_version
+        @rule_records_version ||= 0
+      end
+
       def finalized?
         @finalized
       end
@@ -1334,6 +1341,18 @@ module Lutaml
         !@namespace_class.nil?
       end
 
+      # lutaml-model#154: opt-in decoding of HTML named/numeric entities
+      # (e.g. ©, —) in mapped text and attribute values. XML
+      # documents are otherwise kept byte-faithful: HTML entities are not
+      # defined in XML without a DTD.
+      def html_entities(enabled: true)
+        @decode_html_entities = enabled
+      end
+
+      def decode_html_entities?
+        !!@decode_html_entities
+      end
+
       # Whether namespace was explicitly set via DSL
       def namespace_set?
         !!@namespace_set