lutaml-model 0.8.65 → 0.8.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8bbc0a4da8114a582ee834a333a8614ca1051747296a1e967eb36f47ef68b48
-  data.tar.gz: ec01b4058ae9ce9d400f229ae4f116bcdde25cdd015e3b96ff3e2b39af62ff10
+  metadata.gz: 52c9d5f90fb80dbbec116f4a6e8d65e92d8b5fe3181a9a4b7aa26349b64d8938
+  data.tar.gz: 657ef667d7d9192a6f6d6592168c8bf5c3a3f25aeff8fa4127d4438954ac7bf0
 SHA512:
-  metadata.gz: 494b45969f4e8f67e5f79fe09eb6e1630e5b04109fe46b13210cc8dfe455a11e7b7d7955a91ae2132c037c7e53d21fb09c0462a55899cccaafc4d4e5b609bccd
-  data.tar.gz: 6694a345fda4b371988fab2af07b9311b7eed87f2e61a696eab7c2a247ba04950bbb93439b1019a27903dbfcf8c5815067f2d3449a41affe2cdb21a6a3deb583
+  metadata.gz: 14797b4e4855ac206622648c2ae5cf01b5115e9a243f461861d90e78903a80df356d35144b024801dd9556ed3d89fe526069157faf5bceb804088829be768be4
+  data.tar.gz: 179a58214dc093680917167055d3f3deec644303b310c91763d27c6aed18b19fc1e5668dea0c8a1a1e3542ef54b8d39712ade45a869ee0c072f1bb92ae10c18f

data/docs/_guides/native-engines.adoc

@@ -106,6 +106,13 @@ Lutaml::Model::Config.toml_adapter_type = :teptris
   raising `Psych::DisallowedClass`.
 * **JSON**: `yeptris` parsing targets exact `JSON.parse` semantics;
   generation stays on the `json` gem.
+* **Error classes**: parse failures keep the standard adapters' contract
+  on every engine — the yeptris adapters re-raise the engine's syntax
+  errors as `Psych::SyntaxError` (YAML, with the engine's line, column,
+  and problem text) and `JSON::ParserError` (JSON), and the model layer
+  wraps them as `InvalidFormatError` just as it does for Psych and the
+  `json` gem. Code that rescues those classes does not change when a
+  native engine is added to the bundle.
 * **TOML**: the teptris adapter mirrors tomlib value semantics — offset
   and local datetimes become `Time`, dates become `Date`, local times
   stay `String`. Parse failures raise `Teptris::ParseError` with line

data/lib/lutaml/json/adapter/yeptris_adapter.rb

@@ -12,9 +12,32 @@ module Lutaml
       # load-only), so everything else inherits from the standard adapter.
       class YeptrisAdapter < StandardAdapter
         def self.parse(json, _options = {})
-          require "yeptris"
+          require_engine
           ::Yeptris::JSON.load(json)
+        rescue ::Yeptris::JSON::ParseError => e
+          raise parser_error(e)
+        end
+
+        # The engine require sits outside parse's rescue so a broken
+        # install still surfaces its LoadError (the detection fallback's
+        # contract) instead of a NameError from the rescue clause.
+        def self.require_engine
+          require "yeptris"
+        end
+        private_class_method :require_engine
+
+        # The parse-error contract is the standard adapter's: invalid
+        # input raises JSON::ParserError regardless of the engine, so
+        # consumers' rescue ladders (and this gem's own
+        # format_error_types conversion to InvalidFormatError) hold on
+        # every adapter. Without the json gem the engine error
+        # propagates unchanged.
+        def self.parser_error(error)
+          return error unless defined?(::JSON::ParserError)
+
+          ::JSON::ParserError.new(error.message)
         end
+        private_class_method :parser_error
       end
     end
   end

data/lib/lutaml/model/attribute.rb

@@ -566,10 +566,15 @@ instance_object = nil)
       end
 
       def default_value(register, instance_object = nil)
-        if delegate
-          type(register).attributes(register)[to].default(register,
-                                                          instance_object)
-        elsif options[:default].is_a?(Proc)
+        # The kind is fixed at definition; the common case (no default
+        # at all) paid three option checks per absent attribute per
+        # instantiation before the memo.
+        case (@default_kind ||= _default_kind)
+        when :none
+          Lutaml::Model::UninitializedClass.instance
+        when :static
+          options[:default]
+        when :proc
           if instance_object
             ::Lutaml::Model::Attribute.evaluating_default do
               instance_object.instance_exec(&options[:default])
@@ -577,13 +582,20 @@ instance_object = nil)
           else
             options[:default].call
           end
-        elsif options.key?(:default)
-          options[:default]
-        else
-          Lutaml::Model::UninitializedClass.instance
+        else # :delegate
+          type(register).attributes(register)[to].default(register,
+                                                          instance_object)
         end
       end
 
+      def _default_kind
+        return :delegate if delegate
+        return :proc if options[:default].is_a?(Proc)
+        return :static if options.key?(:default)
+
+        :none
+      end
+
       # Marks the dynamic extent in which a default proc runs against a
       # model instance, so Serialize#method_missing can fall back to the
       # model class for methods the instance does not define (0.7.x

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.65"
+    VERSION = "0.8.67"
   end
 end

data/lib/lutaml/xml/plan_hydrator.rb

@@ -66,14 +66,14 @@ module Lutaml
         def attributes_kwargs(plan, value, node = nil)
           kwargs = {}
           sole_claimants = sole_claimant_names(plan)
-          plan[:attr_rows].each do |rule, attr|
-            v = value.attribute(rule.name.to_s)
-            if v.nil? && node && sole_claimants.include?(rule.name.to_s)
+          plan_attr_rows(plan).each do |rule, attr, name|
+            v = value.attribute(name)
+            if v.nil? && node && sole_claimants.include?(name)
               # #754/#790 parity: a sole-claimant attribute rule binds
               # any qualification (the interpretive matcher's lenient
               # recovery). The walk captures exact (URI, local) matches
               # only, so the qualified spelling is read off the node.
-              v = lenient_node_attribute(node, rule.name.to_s)
+              v = lenient_node_attribute(node, name)
             end
             next if v.nil?
 
@@ -86,6 +86,15 @@ module Lutaml
           kwargs
         end
 
+        # Wire-name strings are plan-frozen; materializing them per
+        # hydration allocated two or three strings per attribute row
+        # per instance.
+        def plan_attr_rows(plan)
+          plan[:attr_row_names] ||= plan[:attr_rows].map do |rule, attr|
+            [rule, attr, rule.name.to_s]
+          end
+        end
+
         # Returns [kwargs, hydrated_child_instances, delegate_values]
         # — child instances come back so the caller can decorate
         # parent/root links once the parent exists; delegate values
@@ -364,10 +373,11 @@ module Lutaml
         # names eligible for #754/#790 lenient binding (multi-claimant
         # names stay exact; per #841 leniency is sole-claimant-only).
         def sole_claimant_names(plan)
-          plan[:attr_rows].map { |rule, _attr| rule.name.to_s }
-            .tally
-            .select { |_n, c| c == 1 }
-            .keys
+          # Frozen with the plan: recomputing the tally per hydration
+          # showed in the #876-era profile as Enumerable#find/tally churn.
+          plan[:sole_claimants] ||= plan[:attr_rows]
+            .map { |rule, _attr| rule.name.to_s }.tally
+            .select { |_n, c| c == 1 }.keys
         end
 
         # Local-name attribute lookup on the source node, qualified
@@ -391,9 +401,12 @@ module Lutaml
           want_tags = !row_tags.nil?
           value.count.times do |i|
             child = value.at(i)
-            next if child.name.nil? # content runs, read separately
+            # One FFI crossing per child: the name was read twice here
+            # (nil check + bucket key), doubling the hottest accessor.
+            name = child.name
+            next if name.nil? # content runs, read separately
 
-            (grouped[child.name] ||= []) << child
+            (grouped[name] ||= []) << child
             if want_tags && child.type_tag != 0
               (tagged[child.type_tag] ||= []) << child
             end

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -14,18 +14,50 @@ module Lutaml
       # Semantic notes vs the standard adapter's Psych.safe_load:
       # implicit typing is parity-verified (compat_11 schema); anchors
       # and aliases always resolve; a tagged value without a core type
-      # materializes as plain data instead of raising DisallowedClass.
+      # materializes as plain data instead of raising DisallowedClass;
+      # parse failures surface as Psych::SyntaxError like the standard
+      # adapter's (the engine's own ParseError is re-raised under the
+      # standard class).
       class YeptrisAdapter < StandardAdapter
         # yeptris is required lazily: the ruby-platform variant installs
         # everywhere but only loads where libyeptris exists (no Windows
         # prebuilts) — a broken install must degrade to detection
         # fallback, never crash loads.
         def self.parse(yaml, _options = {})
-          require "yeptris"
+          require_engine
           require "yeptris/yaml"
           # rubocop:disable-next Naming/VariableNumber -- upstream schema literal
           Yeptris::YAML.load(yaml, schema: :compat_11)
+        rescue Yeptris::ParseError => e
+          raise syntax_error(e)
+        end
+
+        # The engine require sits outside parse's rescue so a broken
+        # install still surfaces its LoadError (the detection fallback's
+        # contract) instead of a NameError from the rescue clause.
+        def self.require_engine
+          require "yeptris"
+        end
+        private_class_method :require_engine
+
+        # The parse-error contract is the standard adapter's: invalid
+        # input raises Psych::SyntaxError regardless of the engine, so
+        # consumers' rescue ladders (and this gem's own
+        # format_error_types conversion to InvalidFormatError) hold on
+        # every adapter. The C parser reports the position inside the
+        # error message ("... at line L, column C"); lift it into the
+        # structured fields. Without psych (Opal) the engine error
+        # propagates unchanged.
+        def self.syntax_error(error)
+          return error unless defined?(::Psych::SyntaxError)
+
+          match = /\bline (\d+),? column (\d+)/.match(error.message)
+          line = match ? match[1].to_i : 0
+          column = match ? match[2].to_i : 0
+          problem = error.message.sub(/\s+at\s+line\s+\d+,?\s+column\s+\d+\z/, "")
+          ::Psych::SyntaxError.new(nil, line, column, 0, problem, nil)
         end
+        private_class_method :syntax_error
 
         def to_yaml(_options = {})
           attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)

data/spec/lutaml/json/yeptris_adapter_spec.rb

@@ -25,9 +25,9 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Json::Adapter::YeptrisAdapter : Objec
         .to eq("a" => 1.5, "b" => nil, "c" => true, "d" => "1e3")
     end
 
-    it "raises on invalid JSON" do
+    it "raises JSON::ParserError on invalid JSON, like the standard adapter" do
       expect { described_class.parse("{nope") }
-        .to raise_error(Yeptris::JSON::ParseError)
+        .to raise_error(JSON::ParserError)
     end
   end
 
@@ -59,5 +59,10 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Json::Adapter::YeptrisAdapter : Objec
       expect(model.roles).to eq(%w[admin dev])
       expect(model_class.from_json(model.to_json).roles).to eq(%w[admin dev])
     end
+
+    it "surfaces invalid JSON as InvalidFormatError" do
+      expect { model_class.from_json("{nope") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
   end
 end

data/spec/lutaml/model/yeptris_error_parity_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "open3"
+require "spec_helper"
+
+# The suite deliberately never loads the optional yeptris engine
+# in-process (adapter_resolver_configured_spec asserts the resolver's
+# lazy-detection guarantee), so the error-class contract is exercised
+# in a subprocess: wherever the engine is installed it is the
+# preferred adapter, and its parse failures must surface under the
+# standard adapters' error classes — Psych::SyntaxError and
+# JSON::ParserError from the adapters, Lutaml::Model::InvalidFormatError
+# through a model — so downstream rescue ladders hold on every engine.
+RSpec.describe "yeptris adapter error parity" do
+  # A direct ruby invocation with explicit load paths and NO shell:
+  # a nested `bundle exec` produced empty output on some CI legs, and
+  # backticks route through cmd.exe on Windows where POSIX quoting
+  # mangles the command. Open3 with array arguments is shell-free on
+  # every platform.
+  subject(:outcomes) do
+    libs = %w[lutaml-model yeptris yeptris-ruby moxml leptris].filter_map do |g|
+      "#{Gem::Specification.find_by_name(g).gem_dir}/lib"
+    rescue Gem::LoadError
+      nil
+    end
+    args = libs.flat_map { |l| ["-I", l] } + ["-e", probe]
+    Open3.capture2e(Gem.ruby, *args).first
+  end
+
+  def yeptris_installed?
+    Gem::Specification.find_by_name("yeptris")
+    true
+  rescue Gem::LoadError
+    false
+  end
+
+  # The probe requires the engine explicitly (the resolved adapters
+  # prove the preference), then reports one outcome line per surface.
+  let(:probe) do
+    <<~RUBY
+      require "lutaml/model"
+
+      def outcome
+        yield
+        "NO-ERROR"
+      rescue StandardError => e
+        "\#{e.class.name}: \#{e.message}"
+      end
+
+      puts "yaml-adapter: \#{Lutaml::Model::AdapterResolver.adapter_for(:yaml).name}"
+      puts "json-adapter: \#{Lutaml::Model::AdapterResolver.adapter_for(:json).name}"
+
+      puts "adapter-yaml: \#{outcome do
+        Lutaml::Yaml::Adapter::YeptrisAdapter.parse("name: test\\n  invalid: [unclosed\\n")
+      end }"
+      puts "adapter-json: \#{outcome do
+        Lutaml::Json::Adapter::YeptrisAdapter.parse("{nope")
+      end }"
+
+      model_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        key_value { map "name", to: :name }
+      end
+      puts "model-yaml: \#{outcome do
+        model_class.from_yaml("name: test\\n  invalid: [unclosed\\n")
+      end }"
+      puts "model-json: \#{outcome do
+        model_class.from_json("{nope")
+      end }"
+    RUBY
+  end
+
+  before { skip "yeptris is not installed" unless yeptris_installed? }
+
+  it "prefers the yeptris adapters when the engine is installed" do
+    expect(outcomes).to include("yaml-adapter: Lutaml::Yaml::Adapter::YeptrisAdapter")
+    expect(outcomes).to include("json-adapter: Lutaml::Json::Adapter::YeptrisAdapter")
+  end
+
+  it "raises Psych::SyntaxError from the yaml adapter for invalid YAML" do
+    expect(outcomes).to match(/^adapter-yaml: Psych::SyntaxError: .+ at line \d+/)
+  end
+
+  it "raises JSON::ParserError from the json adapter for invalid JSON" do
+    expect(outcomes).to match(/^adapter-json: JSON::ParserError: /)
+  end
+
+  it "raises InvalidFormatError through a model for invalid YAML" do
+    expect(outcomes).to match(/^model-yaml: Lutaml::Model::InvalidFormatError: /)
+  end
+
+  it "raises InvalidFormatError through a model for invalid JSON" do
+    expect(outcomes).to match(/^model-json: Lutaml::Model::InvalidFormatError: /)
+  end
+end

data/spec/lutaml/yaml/yeptris_adapter_spec.rb

@@ -30,6 +30,30 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(described_class.parse("d: 2020-01-01\n"))
         .to eq("d" => Date.new(2020, 1, 1))
     end
+
+    it "raises Psych::SyntaxError for invalid YAML, like the standard adapter" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "raises Psych::SyntaxError for a mapping value inside a plain scalar" do
+      # The dependent-CI shape: one line, a second "key:" colon after a
+      # plain scalar run. Psych rejects it with "mapping values are not
+      # allowed in this context"; the engine must surface under the
+      # same class so downstream rescue ladders hold.
+      expect { described_class.parse('name: test\n  invalid: [unclosed') }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "carries the engine's position on the syntax error" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError) do |error|
+        expect(error.line).to be >= 1
+        expect(error.problem).to be_a(String)
+        expect(error.problem).not_to be_empty
+        expect(error.message).to include("at line #{error.line}")
+      end
+    end
   end
 
   describe "#to_yaml" do
@@ -59,5 +83,10 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(model.roles).to eq(%w[admin dev])
       expect(model_class.from_yaml(model.to_yaml).roles).to eq(%w[admin dev])
     end
+
+    it "surfaces invalid YAML as InvalidFormatError" do
+      expect { model_class.from_yaml("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.65
+  version: 0.8.67
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-26 00:00:00.000000000 Z
+date: 2026-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1880,6 +1880,7 @@ files:
 - spec/lutaml/model/yamls_range_spec.rb
 - spec/lutaml/model/yamls_sequence_spec.rb
 - spec/lutaml/model/yamls_spec.rb
+- spec/lutaml/model/yeptris_error_parity_spec.rb
 - spec/lutaml/model_spec.rb
 - spec/lutaml/rdf/context_spec.rb
 - spec/lutaml/rdf/graph_serialization_spec.rb